From a8c54932ba4ba002e7046d36af85f940212df9d1 Mon Sep 17 00:00:00 2001 From: Nobuyoshi Nakada Date: Mon, 8 Jul 2019 14:59:28 +0900 Subject: Renamed fib to fiber --- cont.c | 488 ++++++++++++++++++++++++++++++++--------------------------------- 1 file changed, 244 insertions(+), 244 deletions(-) (limited to 'cont.c') diff --git a/cont.c b/cont.c index 9b28ed1484..b04a0b4290 100644 --- a/cont.c +++ b/cont.c @@ -147,11 +147,11 @@ enum fiber_status { FIBER_TERMINATED }; -#define FIBER_CREATED_P(fib) ((fib)->status == FIBER_CREATED) -#define FIBER_RESUMED_P(fib) ((fib)->status == FIBER_RESUMED) -#define FIBER_SUSPENDED_P(fib) ((fib)->status == FIBER_SUSPENDED) -#define FIBER_TERMINATED_P(fib) ((fib)->status == FIBER_TERMINATED) -#define FIBER_RUNNABLE_P(fib) (FIBER_CREATED_P(fib) || FIBER_SUSPENDED_P(fib)) +#define FIBER_CREATED_P(fiber) ((fiber)->status == FIBER_CREATED) +#define FIBER_RESUMED_P(fiber) ((fiber)->status == FIBER_RESUMED) +#define FIBER_SUSPENDED_P(fiber) ((fiber)->status == FIBER_SUSPENDED) +#define FIBER_TERMINATED_P(fiber) ((fiber)->status == FIBER_TERMINATED) +#define FIBER_RUNNABLE_P(fiber) (FIBER_CREATED_P(fiber) || FIBER_SUSPENDED_P(fiber)) #if FIBER_USE_NATIVE && !defined(FIBER_USE_COROUTINE) && !defined(_WIN32) static inline int @@ -190,7 +190,7 @@ struct rb_fiber_struct { void *ss_sp; size_t ss_size; #elif defined(_WIN32) - void *fib_handle; + void *fiber_handle; #else #define FIBER_ALLOCATE_STACK ucontext_t context; @@ -229,17 +229,17 @@ fiber_status_name(enum fiber_status s) } static void -fiber_verify(const rb_fiber_t *fib) +fiber_verify(const rb_fiber_t *fiber) { #if VM_CHECK_MODE > 0 - VM_ASSERT(fib->cont.saved_ec.fiber_ptr == fib); + VM_ASSERT(fiber->cont.saved_ec.fiber_ptr == fiber); - switch (fib->status) { + switch (fiber->status) { case FIBER_RESUMED: - VM_ASSERT(fib->cont.saved_ec.vm_stack != NULL); + VM_ASSERT(fiber->cont.saved_ec.vm_stack != NULL); break; case FIBER_SUSPENDED: - VM_ASSERT(fib->cont.saved_ec.vm_stack != NULL); + VM_ASSERT(fiber->cont.saved_ec.vm_stack != NULL); break; case FIBER_CREATED: case FIBER_TERMINATED: @@ -260,19 +260,19 @@ rb_ec_verify(const rb_execution_context_t *ec) #endif static void -fiber_status_set(rb_fiber_t *fib, enum fiber_status s) +fiber_status_set(rb_fiber_t *fiber, enum fiber_status s) { - if (0) fprintf(stderr, "fib: %p, status: %s -> %s\n", (void *)fib, fiber_status_name(fib->status), fiber_status_name(s)); - VM_ASSERT(!FIBER_TERMINATED_P(fib)); - VM_ASSERT(fib->status != s); - fiber_verify(fib); - fib->status = s; + if (0) fprintf(stderr, "fiber: %p, status: %s -> %s\n", (void *)fiber, fiber_status_name(fiber->status), fiber_status_name(s)); + VM_ASSERT(!FIBER_TERMINATED_P(fiber)); + VM_ASSERT(fiber->status != s); + fiber_verify(fiber); + fiber->status = s; } static inline void -ec_switch(rb_thread_t *th, rb_fiber_t *fib) +ec_switch(rb_thread_t *th, rb_fiber_t *fiber) { - rb_execution_context_t *ec = &fib->cont.saved_ec; + rb_execution_context_t *ec = &fiber->cont.saved_ec; ruby_current_execution_context_ptr = th->ec = ec; @@ -305,12 +305,12 @@ cont_ptr(VALUE obj) static rb_fiber_t * fiber_ptr(VALUE obj) { - rb_fiber_t *fib; + rb_fiber_t *fiber; - TypedData_Get_Struct(obj, rb_fiber_t, &fiber_data_type, fib); - if (!fib) rb_raise(rb_eFiberError, "uninitialized fiber"); + TypedData_Get_Struct(obj, rb_fiber_t, &fiber_data_type, fiber); + if (!fiber) rb_raise(rb_eFiberError, "uninitialized fiber"); - return fib; + return fiber; } NOINLINE(static VALUE cont_capture(volatile int *volatile stat)); @@ -363,9 +363,9 @@ cont_mark(void *ptr) } else { /* fiber */ - const rb_fiber_t *fib = (rb_fiber_t*)cont; + const rb_fiber_t *fiber = (rb_fiber_t*)cont; - if (!FIBER_TERMINATED_P(fib)) { + if (!FIBER_TERMINATED_P(fiber)) { rb_gc_mark_locations(cont->machine.stack, cont->machine.stack + cont->machine.stack_size); } @@ -376,9 +376,9 @@ cont_mark(void *ptr) } static int -fiber_is_root_p(const rb_fiber_t *fib) +fiber_is_root_p(const rb_fiber_t *fiber) { - return fib == fib->cont.saved_ec.thread_ptr->root_fiber; + return fiber == fiber->cont.saved_ec.thread_ptr->root_fiber; } static void @@ -400,31 +400,31 @@ cont_free(void *ptr) } else { /* fiber */ - rb_fiber_t *fib = (rb_fiber_t*)cont; + rb_fiber_t *fiber = (rb_fiber_t*)cont; #if defined(FIBER_USE_COROUTINE) - coroutine_destroy(&fib->context); - if (fib->ss_sp != NULL) { - if (fiber_is_root_p(fib)) { + coroutine_destroy(&fiber->context); + if (fiber->ss_sp != NULL) { + if (fiber_is_root_p(fiber)) { rb_bug("Illegal root fiber parameter"); } #ifdef _WIN32 - VirtualFree((void*)fib->ss_sp, 0, MEM_RELEASE); + VirtualFree((void*)fiber->ss_sp, 0, MEM_RELEASE); #else - munmap((void*)fib->ss_sp, fib->ss_size); + munmap((void*)fiber->ss_sp, fiber->ss_size); #endif - fib->ss_sp = NULL; + fiber->ss_sp = NULL; } #elif defined(_WIN32) - if (!fiber_is_root_p(fib)) { + if (!fiber_is_root_p(fiber)) { /* don't delete root fiber handle */ - if (fib->fib_handle) { - DeleteFiber(fib->fib_handle); + if (fiber->fiber_handle) { + DeleteFiber(fiber->fiber_handle); } } #else /* not WIN32 */ - /* fib->ss_sp == NULL is possible for root fiber */ - if (fib->ss_sp != NULL) { - munmap((void*)fib->ss_sp, fib->ss_size); + /* fiber->ss_sp == NULL is possible for root fiber */ + if (fiber->ss_sp != NULL) { + munmap((void*)fiber->ss_sp, fiber->ss_size); } #endif } @@ -466,90 +466,90 @@ cont_memsize(const void *ptr) } void -rb_fiber_update_self(rb_fiber_t *fib) +rb_fiber_update_self(rb_fiber_t *fiber) { - if (fib->cont.self) { - fib->cont.self = rb_gc_location(fib->cont.self); + if (fiber->cont.self) { + fiber->cont.self = rb_gc_location(fiber->cont.self); } else { - rb_execution_context_update(&fib->cont.saved_ec); + rb_execution_context_update(&fiber->cont.saved_ec); } } void -rb_fiber_mark_self(const rb_fiber_t *fib) +rb_fiber_mark_self(const rb_fiber_t *fiber) { - if (fib->cont.self) { - rb_gc_mark_no_pin(fib->cont.self); + if (fiber->cont.self) { + rb_gc_mark_no_pin(fiber->cont.self); } else { - rb_execution_context_mark(&fib->cont.saved_ec); + rb_execution_context_mark(&fiber->cont.saved_ec); } } static void fiber_compact(void *ptr) { - rb_fiber_t *fib = ptr; - fib->first_proc = rb_gc_location(fib->first_proc); + rb_fiber_t *fiber = ptr; + fiber->first_proc = rb_gc_location(fiber->first_proc); - if (fib->prev) rb_fiber_update_self(fib->prev); + if (fiber->prev) rb_fiber_update_self(fiber->prev); - cont_compact(&fib->cont); - fiber_verify(fib); + cont_compact(&fiber->cont); + fiber_verify(fiber); } static void fiber_mark(void *ptr) { - rb_fiber_t *fib = ptr; + rb_fiber_t *fiber = ptr; RUBY_MARK_ENTER("cont"); - fiber_verify(fib); - rb_gc_mark_no_pin(fib->first_proc); - if (fib->prev) rb_fiber_mark_self(fib->prev); + fiber_verify(fiber); + rb_gc_mark_no_pin(fiber->first_proc); + if (fiber->prev) rb_fiber_mark_self(fiber->prev); #if !FIBER_USE_NATIVE - if (fib->status == FIBER_TERMINATED) { + if (fiber->status == FIBER_TERMINATED) { /* FIBER_TERMINATED fiber should not mark machine stack */ - if (fib->cont.saved_ec.machine.stack_end != NULL) { - fib->cont.saved_ec.machine.stack_end = NULL; + if (fiber->cont.saved_ec.machine.stack_end != NULL) { + fiber->cont.saved_ec.machine.stack_end = NULL; } } #endif - cont_mark(&fib->cont); + cont_mark(&fiber->cont); RUBY_MARK_LEAVE("cont"); } static void fiber_free(void *ptr) { - rb_fiber_t *fib = ptr; + rb_fiber_t *fiber = ptr; RUBY_FREE_ENTER("fiber"); - if (fib->cont.saved_ec.local_storage) { - st_free_table(fib->cont.saved_ec.local_storage); + if (fiber->cont.saved_ec.local_storage) { + st_free_table(fiber->cont.saved_ec.local_storage); } - cont_free(&fib->cont); + cont_free(&fiber->cont); RUBY_FREE_LEAVE("fiber"); } static size_t fiber_memsize(const void *ptr) { - const rb_fiber_t *fib = ptr; - size_t size = sizeof(*fib); - const rb_execution_context_t *saved_ec = &fib->cont.saved_ec; + const rb_fiber_t *fiber = ptr; + size_t size = sizeof(*fiber); + const rb_execution_context_t *saved_ec = &fiber->cont.saved_ec; const rb_thread_t *th = rb_ec_thread_ptr(saved_ec); /* * vm.c::thread_memsize already counts th->ec->local_storage */ - if (saved_ec->local_storage && fib != th->root_fiber) { + if (saved_ec->local_storage && fiber != th->root_fiber) { size += st_memsize(saved_ec->local_storage); } - size += cont_memsize(&fib->cont); + size += cont_memsize(&fiber->cont); return size; } @@ -736,10 +736,10 @@ cont_capture(volatile int *volatile stat) COMPILER_WARNING_POP static inline void -fiber_restore_thread(rb_thread_t *th, rb_fiber_t *fib) +fiber_restore_thread(rb_thread_t *th, rb_fiber_t *fiber) { - ec_switch(th, fib); - VM_ASSERT(th->ec->fiber_ptr == fib); + ec_switch(th, fiber); + VM_ASSERT(th->ec->fiber_ptr == fiber); } static inline void @@ -751,17 +751,17 @@ cont_restore_thread(rb_context_t *cont) if (cont->type == CONTINUATION_CONTEXT) { /* continuation */ rb_execution_context_t *sec = &cont->saved_ec; - rb_fiber_t *fib = NULL; + rb_fiber_t *fiber = NULL; if (sec->fiber_ptr != NULL) { - fib = sec->fiber_ptr; + fiber = sec->fiber_ptr; } else if (th->root_fiber) { - fib = th->root_fiber; + fiber = th->root_fiber; } - if (fib && th->ec != &fib->cont.saved_ec) { - ec_switch(th, fib); + if (fiber && th->ec != &fiber->cont.saved_ec) { + ec_switch(th, fiber); } if (th->ec->trace_arg != sec->trace_arg) { @@ -902,18 +902,18 @@ fiber_machine_stack_alloc(size_t size) #if FIBER_USE_NATIVE static void -fiber_initialize_machine_stack_context(rb_fiber_t *fib, size_t size) +fiber_initialize_machine_stack_context(rb_fiber_t *fiber, size_t size) { - rb_execution_context_t *sec = &fib->cont.saved_ec; + rb_execution_context_t *sec = &fiber->cont.saved_ec; #if defined(FIBER_USE_COROUTINE) char *ptr; STACK_GROW_DIR_DETECTION; ptr = fiber_machine_stack_alloc(size); - fib->ss_sp = ptr; - fib->ss_size = size; - coroutine_initialize(&fib->context, fiber_entry, ptr, size); + fiber->ss_sp = ptr; + fiber->ss_size = size; + coroutine_initialize(&fiber->context, fiber_entry, ptr, size); sec->machine.stack_start = (VALUE*)(ptr + STACK_DIR_UPPER(0, size)); sec->machine.stack_maxsize = size - RB_PAGE_SIZE; #elif defined(_WIN32) @@ -921,12 +921,12 @@ fiber_initialize_machine_stack_context(rb_fiber_t *fib, size_t size) # define CreateFiberEx(cs, stacksize, flags, entry, param) \ CreateFiber((stacksize), (entry), (param)) # endif - fib->fib_handle = CreateFiberEx(size - 1, size, 0, fiber_entry, NULL); - if (!fib->fib_handle) { + fiber->fiber_handle = CreateFiberEx(size - 1, size, 0, fiber_entry, NULL); + if (!fiber->fiber_handle) { /* try to release unnecessary fibers & retry to create */ rb_gc(); - fib->fib_handle = CreateFiberEx(size - 1, size, 0, fiber_entry, NULL); - if (!fib->fib_handle) { + fiber->fiber_handle = CreateFiberEx(size - 1, size, 0, fiber_entry, NULL); + if (!fiber->fiber_handle) { rb_raise(rb_eFiberError, "can't create fiber"); } } @@ -936,9 +936,9 @@ fiber_initialize_machine_stack_context(rb_fiber_t *fib, size_t size) STACK_GROW_DIR_DETECTION; ptr = fiber_machine_stack_alloc(size); - fib->ss_sp = ptr; - fib->ss_size = size; - if (fiber_context_create(&fib->context, fiber_entry, NULL, fib->ss_sp, fib->ss_size)) { + fiber->ss_sp = ptr; + fiber->ss_size = size; + if (fiber_context_create(&fiber->context, fiber_entry, NULL, fiber->ss_sp, fiber->ss_size)) { rb_raise(rb_eFiberError, "can't get context for creating fiber: %s", ERRNOMSG); } sec->machine.stack_start = (VALUE*)(ptr + STACK_DIR_UPPER(0, size)); @@ -946,46 +946,46 @@ fiber_initialize_machine_stack_context(rb_fiber_t *fib, size_t size) #endif } -NOINLINE(static void fiber_setcontext(rb_fiber_t *newfib, rb_fiber_t *oldfib)); +NOINLINE(static void fiber_setcontext(rb_fiber_t *new_fiber, rb_fiber_t *old_fiber)); static void -fiber_setcontext(rb_fiber_t *newfib, rb_fiber_t *oldfib) +fiber_setcontext(rb_fiber_t *new_fiber, rb_fiber_t *old_fiber) { rb_thread_t *th = GET_THREAD(); - /* save oldfib's machine stack / TODO: is it needed? */ - if (!FIBER_TERMINATED_P(oldfib)) { + /* save old_fiber's machine stack / TODO: is it needed? */ + if (!FIBER_TERMINATED_P(old_fiber)) { STACK_GROW_DIR_DETECTION; SET_MACHINE_STACK_END(&th->ec->machine.stack_end); if (STACK_DIR_UPPER(0, 1)) { - oldfib->cont.machine.stack_size = th->ec->machine.stack_start - th->ec->machine.stack_end; - oldfib->cont.machine.stack = th->ec->machine.stack_end; + old_fiber->cont.machine.stack_size = th->ec->machine.stack_start - th->ec->machine.stack_end; + old_fiber->cont.machine.stack = th->ec->machine.stack_end; } else { - oldfib->cont.machine.stack_size = th->ec->machine.stack_end - th->ec->machine.stack_start; - oldfib->cont.machine.stack = th->ec->machine.stack_start; + old_fiber->cont.machine.stack_size = th->ec->machine.stack_end - th->ec->machine.stack_start; + old_fiber->cont.machine.stack = th->ec->machine.stack_start; } } - /* exchange machine_stack_start between oldfib and newfib */ - oldfib->cont.saved_ec.machine.stack_start = th->ec->machine.stack_start; + /* exchange machine_stack_start between old_fiber and new_fiber */ + old_fiber->cont.saved_ec.machine.stack_start = th->ec->machine.stack_start; - /* oldfib->machine.stack_end should be NULL */ - oldfib->cont.saved_ec.machine.stack_end = NULL; + /* old_fiber->machine.stack_end should be NULL */ + old_fiber->cont.saved_ec.machine.stack_end = NULL; /* restore thread context */ - fiber_restore_thread(th, newfib); + fiber_restore_thread(th, new_fiber); /* swap machine context */ #if defined(FIBER_USE_COROUTINE) - coroutine_transfer(&oldfib->context, &newfib->context); + coroutine_transfer(&old_fiber->context, &new_fiber->context); #elif defined(_WIN32) - SwitchToFiber(newfib->fib_handle); + SwitchToFiber(new_fiber->fiber_handle); #else - if (!newfib->context.uc_stack.ss_sp && th->root_fiber != newfib) { + if (!new_fiber->context.uc_stack.ss_sp && th->root_fiber != new_fiber) { rb_bug("non_root_fiber->context.uc_stac.ss_sp should not be NULL"); } - swapcontext(&oldfib->context, &newfib->context); + swapcontext(&old_fiber->context, &new_fiber->context); #endif } #endif /* FIBER_USE_NATIVE */ @@ -1374,30 +1374,30 @@ fiber_alloc(VALUE klass) } static rb_fiber_t* -fiber_t_alloc(VALUE fibval) +fiber_t_alloc(VALUE fiber_value) { - rb_fiber_t *fib; + rb_fiber_t *fiber; rb_thread_t *th = GET_THREAD(); - if (DATA_PTR(fibval) != 0) { + if (DATA_PTR(fiber_value) != 0) { rb_raise(rb_eRuntimeError, "cannot initialize twice"); } THREAD_MUST_BE_RUNNING(th); - fib = ZALLOC(rb_fiber_t); - fib->cont.self = fibval; - fib->cont.type = FIBER_CONTEXT; - cont_init(&fib->cont, th); - fib->cont.saved_ec.fiber_ptr = fib; - fib->prev = NULL; + fiber = ZALLOC(rb_fiber_t); + fiber->cont.self = fiber_value; + fiber->cont.type = FIBER_CONTEXT; + cont_init(&fiber->cont, th); + fiber->cont.saved_ec.fiber_ptr = fiber; + fiber->prev = NULL; - /* fib->status == 0 == CREATED - * So that we don't need to set status: fiber_status_set(fib, FIBER_CREATED); */ - VM_ASSERT(FIBER_CREATED_P(fib)); + /* fiber->status == 0 == CREATED + * So that we don't need to set status: fiber_status_set(fiber, FIBER_CREATED); */ + VM_ASSERT(FIBER_CREATED_P(fiber)); - DATA_PTR(fibval) = fib; + DATA_PTR(fiber_value) = fiber; - return fib; + return fiber; } rb_control_frame_t * @@ -1413,47 +1413,47 @@ rb_vm_push_frame(rb_execution_context_t *sec, int stack_max); static VALUE -fiber_init(VALUE fibval, VALUE proc) +fiber_init(VALUE fiber_value, VALUE proc) { - rb_fiber_t *fib = fiber_t_alloc(fibval); - rb_context_t *cont = &fib->cont; + rb_fiber_t *fiber = fiber_t_alloc(fiber_value); + rb_context_t *cont = &fiber->cont; rb_execution_context_t *sec = &cont->saved_ec; rb_thread_t *cth = GET_THREAD(); rb_vm_t *vm = cth->vm; - size_t fib_stack_bytes = vm->default_params.fiber_vm_stack_size; + size_t fiber_stack_bytes = vm->default_params.fiber_vm_stack_size; size_t thr_stack_bytes = vm->default_params.thread_vm_stack_size; VALUE *vm_stack; /* initialize cont */ cont->saved_vm_stack.ptr = NULL; - if (fib_stack_bytes == thr_stack_bytes) { - vm_stack = rb_thread_recycle_stack(fib_stack_bytes / sizeof(VALUE)); + if (fiber_stack_bytes == thr_stack_bytes) { + vm_stack = rb_thread_recycle_stack(fiber_stack_bytes / sizeof(VALUE)); } else { - vm_stack = ruby_xmalloc(fib_stack_bytes); + vm_stack = ruby_xmalloc(fiber_stack_bytes); } cont->free_vm_stack = 1; - rb_ec_initialize_vm_stack(sec, vm_stack, fib_stack_bytes / sizeof(VALUE)); + rb_ec_initialize_vm_stack(sec, vm_stack, fiber_stack_bytes / sizeof(VALUE)); sec->tag = NULL; sec->local_storage = NULL; sec->local_storage_recursive_hash = Qnil; sec->local_storage_recursive_hash_for_trace = Qnil; - fib->first_proc = proc; + fiber->first_proc = proc; #if !FIBER_USE_NATIVE MEMCPY(&cont->jmpbuf, &cth->root_jmpbuf, rb_jmpbuf_t, 1); #endif - return fibval; + return fiber_value; } /* :nodoc: */ static VALUE -rb_fiber_init(VALUE fibval) +rb_fiber_init(VALUE fiber_value) { - return fiber_init(fibval, rb_block_proc()); + return fiber_init(fiber_value, rb_block_proc()); } VALUE @@ -1462,30 +1462,30 @@ rb_fiber_new(VALUE (*func)(ANYARGS), VALUE obj) return fiber_init(fiber_alloc(rb_cFiber), rb_proc_new(func, obj)); } -static void rb_fiber_terminate(rb_fiber_t *fib, int need_interrupt); +static void rb_fiber_terminate(rb_fiber_t *fiber, int need_interrupt); void rb_fiber_start(void) { rb_thread_t * volatile th = GET_THREAD(); - rb_fiber_t *fib = th->ec->fiber_ptr; + rb_fiber_t *fiber = th->ec->fiber_ptr; rb_proc_t *proc; enum ruby_tag_type state; int need_interrupt = TRUE; VM_ASSERT(th->ec == ruby_current_execution_context_ptr); - VM_ASSERT(FIBER_RESUMED_P(fib)); + VM_ASSERT(FIBER_RESUMED_P(fiber)); EC_PUSH_TAG(th->ec); if ((state = EC_EXEC_TAG()) == TAG_NONE) { - rb_context_t *cont = &VAR_FROM_MEMORY(fib)->cont; + rb_context_t *cont = &VAR_FROM_MEMORY(fiber)->cont; int argc; const VALUE *argv, args = cont->value; - GetProcPtr(fib->first_proc, proc); + GetProcPtr(fiber->first_proc, proc); argv = (argc = cont->argc) > 1 ? RARRAY_CONST_PTR(args) : &args; cont->value = Qnil; th->ec->errinfo = Qnil; - th->ec->root_lep = rb_vm_proc_local_ep(fib->first_proc); + th->ec->root_lep = rb_vm_proc_local_ep(fiber->first_proc); th->ec->root_svar = Qfalse; EXEC_EVENT_HOOK(th->ec, RUBY_EVENT_FIBER_SWITCH, th->self, 0, 0, 0, Qnil); @@ -1495,7 +1495,7 @@ rb_fiber_start(void) if (state) { VALUE err = th->ec->errinfo; - VM_ASSERT(FIBER_RESUMED_P(fib)); + VM_ASSERT(FIBER_RESUMED_P(fiber)); if (state == TAG_RAISE || state == TAG_FATAL) { rb_threadptr_pending_interrupt_enque(th, err); @@ -1509,57 +1509,57 @@ rb_fiber_start(void) need_interrupt = TRUE; } - rb_fiber_terminate(fib, need_interrupt); + rb_fiber_terminate(fiber, need_interrupt); VM_UNREACHABLE(rb_fiber_start); } static rb_fiber_t * root_fiber_alloc(rb_thread_t *th) { - VALUE fibval = fiber_alloc(rb_cFiber); - rb_fiber_t *fib = th->ec->fiber_ptr; + VALUE fiber_value = fiber_alloc(rb_cFiber); + rb_fiber_t *fiber = th->ec->fiber_ptr; - VM_ASSERT(DATA_PTR(fibval) == NULL); - VM_ASSERT(fib->cont.type == FIBER_CONTEXT); - VM_ASSERT(fib->status == FIBER_RESUMED); + VM_ASSERT(DATA_PTR(fiber_value) == NULL); + VM_ASSERT(fiber->cont.type == FIBER_CONTEXT); + VM_ASSERT(fiber->status == FIBER_RESUMED); - th->root_fiber = fib; - DATA_PTR(fibval) = fib; - fib->cont.self = fibval; + th->root_fiber = fiber; + DATA_PTR(fiber_value) = fiber; + fiber->cont.self = fiber_value; #if FIBER_USE_NATIVE #if defined(FIBER_USE_COROUTINE) - coroutine_initialize_main(&fib->context); + coroutine_initialize_main(&fiber->context); #elif defined(_WIN32) - /* setup fib_handle for root Fiber */ - if (fib->fib_handle == 0) { - if ((fib->fib_handle = ConvertThreadToFiber(0)) == 0) { + /* setup fiber_handle for root Fiber */ + if (fiber->fiber_handle == 0) { + if ((fiber->fiber_handle = ConvertThreadToFiber(0)) == 0) { rb_bug("root_fiber_alloc: ConvertThreadToFiber() failed - %s\n", rb_w32_strerror(-1)); } } else { - rb_bug("root_fiber_alloc: fib_handle is not NULL."); + rb_bug("root_fiber_alloc: fiber_handle is not NULL."); } #endif #endif - return fib; + return fiber; } void rb_threadptr_root_fiber_setup(rb_thread_t *th) { - rb_fiber_t *fib = ruby_mimmalloc(sizeof(rb_fiber_t)); - MEMZERO(fib, rb_fiber_t, 1); - fib->cont.type = FIBER_CONTEXT; - fib->cont.saved_ec.fiber_ptr = fib; - fib->cont.saved_ec.thread_ptr = th; - fiber_status_set(fib, FIBER_RESUMED); /* skip CREATED */ - th->ec = &fib->cont.saved_ec; + rb_fiber_t *fiber = ruby_mimmalloc(sizeof(rb_fiber_t)); + MEMZERO(fiber, rb_fiber_t, 1); + fiber->cont.type = FIBER_CONTEXT; + fiber->cont.saved_ec.fiber_ptr = fiber; + fiber->cont.saved_ec.thread_ptr = th; + fiber_status_set(fiber, FIBER_RESUMED); /* skip CREATED */ + th->ec = &fiber->cont.saved_ec; - VM_ASSERT(fib->cont.free_vm_stack == 0); + VM_ASSERT(fiber->cont.free_vm_stack == 0); - /* NOTE: On WIN32, fib_handle is not allocated yet. */ + /* NOTE: On WIN32, fiber_handle is not allocated yet. */ } void @@ -1606,8 +1606,8 @@ fiber_current(void) static inline rb_fiber_t* return_fiber(void) { - rb_fiber_t *fib = fiber_current(); - rb_fiber_t *prev = fib->prev; + rb_fiber_t *fiber = fiber_current(); + rb_fiber_t *prev = fiber->prev; if (!prev) { rb_thread_t *th = GET_THREAD(); @@ -1615,13 +1615,13 @@ return_fiber(void) VM_ASSERT(root_fiber != NULL); - if (root_fiber == fib) { + if (root_fiber == fiber) { rb_raise(rb_eFiberError, "can't yield from root fiber"); } return root_fiber; } else { - fib->prev = NULL; + fiber->prev = NULL; return prev; } } @@ -1633,38 +1633,38 @@ rb_fiber_current(void) } static inline VALUE -fiber_store(rb_fiber_t *next_fib, rb_thread_t *th) +fiber_store(rb_fiber_t *next_fiber, rb_thread_t *th) { - rb_fiber_t *fib; + rb_fiber_t *fiber; if (th->ec->fiber_ptr != NULL) { - fib = th->ec->fiber_ptr; + fiber = th->ec->fiber_ptr; } else { /* create root fiber */ - fib = root_fiber_alloc(th); + fiber = root_fiber_alloc(th); } - VM_ASSERT(FIBER_RESUMED_P(fib) || FIBER_TERMINATED_P(fib)); - VM_ASSERT(FIBER_RUNNABLE_P(next_fib)); + VM_ASSERT(FIBER_RESUMED_P(fiber) || FIBER_TERMINATED_P(fiber)); + VM_ASSERT(FIBER_RUNNABLE_P(next_fiber)); #if FIBER_USE_NATIVE - if (FIBER_CREATED_P(next_fib)) { - fiber_initialize_machine_stack_context(next_fib, th->vm->default_params.fiber_machine_stack_size); + if (FIBER_CREATED_P(next_fiber)) { + fiber_initialize_machine_stack_context(next_fiber, th->vm->default_params.fiber_machine_stack_size); } #endif - if (FIBER_RESUMED_P(fib)) fiber_status_set(fib, FIBER_SUSPENDED); + if (FIBER_RESUMED_P(fiber)) fiber_status_set(fiber, FIBER_SUSPENDED); #if FIBER_USE_NATIVE == 0 - /* should (re-)allocate stack are before fib->status change to pass fiber_verify() */ - cont_save_machine_stack(th, &fib->cont); + /* should (re-)allocate stack are before fiber->status change to pass fiber_verify() */ + cont_save_machine_stack(th, &fiber->cont); #endif - fiber_status_set(next_fib, FIBER_RESUMED); + fiber_status_set(next_fiber, FIBER_RESUMED); #if FIBER_USE_NATIVE - fiber_setcontext(next_fib, fib); + fiber_setcontext(next_fiber, fiber); /* restored */ #ifdef MAX_MACHINE_STACK_CACHE if (terminated_machine_stack.ptr) { @@ -1672,7 +1672,7 @@ fiber_store(rb_fiber_t *next_fib, rb_thread_t *th) machine_stack_cache[machine_stack_cache_index++] = terminated_machine_stack; } else { - if (terminated_machine_stack.ptr != fib->cont.machine.stack) { + if (terminated_machine_stack.ptr != fiber->cont.machine.stack) { #ifdef _WIN32 VirtualFree(terminated_machine_stack.ptr, 0, MEM_RELEASE); #else @@ -1687,41 +1687,41 @@ fiber_store(rb_fiber_t *next_fib, rb_thread_t *th) terminated_machine_stack.size = 0; } #endif /* MAX_MACHINE_STACK_CACHE */ - fib = th->ec->fiber_ptr; - if (fib->cont.argc == -1) rb_exc_raise(fib->cont.value); - return fib->cont.value; + fiber = th->ec->fiber_ptr; + if (fiber->cont.argc == -1) rb_exc_raise(fiber->cont.value); + return fiber->cont.value; #else /* FIBER_USE_NATIVE */ - fib->cont.saved_ec.machine.stack_end = NULL; - if (ruby_setjmp(fib->cont.jmpbuf)) { + fiber->cont.saved_ec.machine.stack_end = NULL; + if (ruby_setjmp(fiber->cont.jmpbuf)) { /* restored */ - fib = th->ec->fiber_ptr; - if (fib->cont.argc == -1) rb_exc_raise(fib->cont.value); - if (next_fib->cont.value == Qundef) { - cont_restore_0(&next_fib->cont, &next_fib->cont.value); + fiber = th->ec->fiber_ptr; + if (fiber->cont.argc == -1) rb_exc_raise(fiber->cont.value); + if (next_fiber->cont.value == Qundef) { + cont_restore_0(&next_fiber->cont, &next_fiber->cont.value); VM_UNREACHABLE(fiber_store); } - return fib->cont.value; + return fiber->cont.value; } else { VALUE undef = Qundef; - cont_restore_0(&next_fib->cont, &undef); + cont_restore_0(&next_fiber->cont, &undef); VM_UNREACHABLE(fiber_store); } #endif /* FIBER_USE_NATIVE */ } static inline VALUE -fiber_switch(rb_fiber_t *fib, int argc, const VALUE *argv, int is_resume) +fiber_switch(rb_fiber_t *fiber, int argc, const VALUE *argv, int is_resume) { VALUE value; - rb_context_t *cont = &fib->cont; + rb_context_t *cont = &fiber->cont; rb_thread_t *th = GET_THREAD(); /* make sure the root_fiber object is available */ if (th->root_fiber == NULL) root_fiber_alloc(th); - if (th->ec->fiber_ptr == fib) { + if (th->ec->fiber_ptr == fiber) { /* ignore fiber context switch * because destination fiber is same as current fiber */ @@ -1734,7 +1734,7 @@ fiber_switch(rb_fiber_t *fib, int argc, const VALUE *argv, int is_resume) else if (cont->saved_ec.protect_tag != th->ec->protect_tag) { rb_raise(rb_eFiberError, "fiber called across stack rewinding barrier"); } - else if (FIBER_TERMINATED_P(fib)) { + else if (FIBER_TERMINATED_P(fiber)) { value = rb_exc_new2(rb_eFiberError, "dead fiber called"); if (!FIBER_TERMINATED_P(th->ec->fiber_ptr)) { @@ -1760,14 +1760,14 @@ fiber_switch(rb_fiber_t *fib, int argc, const VALUE *argv, int is_resume) } if (is_resume) { - fib->prev = fiber_current(); + fiber->prev = fiber_current(); } - VM_ASSERT(FIBER_RUNNABLE_P(fib)); + VM_ASSERT(FIBER_RUNNABLE_P(fiber)); cont->argc = argc; cont->value = make_passing_arg(argc, argv); - value = fiber_store(fib, th); + value = fiber_store(fiber, th); RUBY_VM_CHECK_INTS(th->ec); EXEC_EVENT_HOOK(th->ec, RUBY_EVENT_FIBER_SWITCH, th->self, 0, 0, 0, Qnil); @@ -1776,20 +1776,20 @@ fiber_switch(rb_fiber_t *fib, int argc, const VALUE *argv, int is_resume) } VALUE -rb_fiber_transfer(VALUE fibval, int argc, const VALUE *argv) +rb_fiber_transfer(VALUE fiber_value, int argc, const VALUE *argv) { - return fiber_switch(fiber_ptr(fibval), argc, argv, 0); + return fiber_switch(fiber_ptr(fiber_value), argc, argv, 0); } void -rb_fiber_close(rb_fiber_t *fib) +rb_fiber_close(rb_fiber_t *fiber) { - rb_execution_context_t *ec = &fib->cont.saved_ec; + rb_execution_context_t *ec = &fiber->cont.saved_ec; VALUE *vm_stack = ec->vm_stack; size_t stack_bytes = ec->vm_stack_size * sizeof(VALUE); - fiber_status_set(fib, FIBER_TERMINATED); - if (fib->cont.free_vm_stack) { + fiber_status_set(fiber, FIBER_TERMINATED); + if (fiber->cont.free_vm_stack) { if (stack_bytes == rb_ec_vm_ptr(ec)->default_params.thread_vm_stack_size) { rb_thread_recycle_stack_release(vm_stack); } @@ -1807,54 +1807,54 @@ rb_fiber_close(rb_fiber_t *fib) } static void -rb_fiber_terminate(rb_fiber_t *fib, int need_interrupt) +rb_fiber_terminate(rb_fiber_t *fiber, int need_interrupt) { - VALUE value = fib->cont.value; - rb_fiber_t *ret_fib; + VALUE value = fiber->cont.value; + rb_fiber_t *ret_fiber; - VM_ASSERT(FIBER_RESUMED_P(fib)); - rb_fiber_close(fib); + VM_ASSERT(FIBER_RESUMED_P(fiber)); + rb_fiber_close(fiber); #if FIBER_USE_NATIVE #if defined(FIBER_USE_COROUTINE) - coroutine_destroy(&fib->context); + coroutine_destroy(&fiber->context); #elif !defined(_WIN32) - fib->context.uc_stack.ss_sp = NULL; + fiber->context.uc_stack.ss_sp = NULL; #endif #ifdef MAX_MACHINE_STACK_CACHE /* Ruby must not switch to other thread until storing terminated_machine_stack */ - terminated_machine_stack.ptr = fib->ss_sp; - terminated_machine_stack.size = fib->ss_size / sizeof(VALUE); - fib->ss_sp = NULL; - fib->cont.machine.stack = NULL; - fib->cont.machine.stack_size = 0; + terminated_machine_stack.ptr = fiber->ss_sp; + terminated_machine_stack.size = fiber->ss_size / sizeof(VALUE); + fiber->ss_sp = NULL; + fiber->cont.machine.stack = NULL; + fiber->cont.machine.stack_size = 0; #endif #endif - ret_fib = return_fiber(); - if (need_interrupt) RUBY_VM_SET_INTERRUPT(&ret_fib->cont.saved_ec); - fiber_switch(ret_fib, 1, &value, 0); + ret_fiber = return_fiber(); + if (need_interrupt) RUBY_VM_SET_INTERRUPT(&ret_fiber->cont.saved_ec); + fiber_switch(ret_fiber, 1, &value, 0); } VALUE -rb_fiber_resume(VALUE fibval, int argc, const VALUE *argv) +rb_fiber_resume(VALUE fiber_value, int argc, const VALUE *argv) { - rb_fiber_t *fib = fiber_ptr(fibval); + rb_fiber_t *fiber = fiber_ptr(fiber_value); - if (argc == -1 && FIBER_CREATED_P(fib)) { + if (argc == -1 && FIBER_CREATED_P(fiber)) { rb_raise(rb_eFiberError, "cannot raise exception on unborn fiber"); } - if (fib->prev != 0 || fiber_is_root_p(fib)) { + if (fiber->prev != 0 || fiber_is_root_p(fiber)) { rb_raise(rb_eFiberError, "double resume"); } - if (fib->transferred != 0) { + if (fiber->transferred != 0) { rb_raise(rb_eFiberError, "cannot resume transferred Fiber"); } - return fiber_switch(fib, argc, argv, 1); + return fiber_switch(fiber, argc, argv, 1); } VALUE @@ -1881,9 +1881,9 @@ rb_fiber_reset_root_local_storage(rb_thread_t *th) * before using this method. */ VALUE -rb_fiber_alive_p(VALUE fibval) +rb_fiber_alive_p(VALUE fiber_value) { - return FIBER_TERMINATED_P(fiber_ptr(fibval)) ? Qfalse : Qtrue; + return FIBER_TERMINATED_P(fiber_ptr(fiber_value)) ? Qfalse : Qtrue; } /* @@ -1902,9 +1902,9 @@ rb_fiber_alive_p(VALUE fibval) * Fiber.yield */ static VALUE -rb_fiber_m_resume(int argc, VALUE *argv, VALUE fib) +rb_fiber_m_resume(int argc, VALUE *argv, VALUE fiber) { - return rb_fiber_resume(fib, argc, argv); + return rb_fiber_resume(fiber, argc, argv); } /* @@ -1927,10 +1927,10 @@ rb_fiber_m_resume(int argc, VALUE *argv, VALUE fib) * blocks. */ static VALUE -rb_fiber_raise(int argc, VALUE *argv, VALUE fib) +rb_fiber_raise(int argc, VALUE *argv, VALUE fiber) { VALUE exc = rb_make_exception(argc, argv); - return rb_fiber_resume(fib, -1, &exc); + return rb_fiber_resume(fiber, -1, &exc); } /* @@ -1979,11 +1979,11 @@ rb_fiber_raise(int argc, VALUE *argv, VALUE fib) * */ static VALUE -rb_fiber_m_transfer(int argc, VALUE *argv, VALUE fibval) +rb_fiber_m_transfer(int argc, VALUE *argv, VALUE fiber_value) { - rb_fiber_t *fib = fiber_ptr(fibval); - fib->transferred = 1; - return fiber_switch(fib, argc, argv, 0); + rb_fiber_t *fiber = fiber_ptr(fiber_value); + fiber->transferred = 1; + return fiber_switch(fiber, argc, argv, 0); } /* @@ -2025,22 +2025,22 @@ rb_fiber_s_current(VALUE klass) */ static VALUE -fiber_to_s(VALUE fibval) +fiber_to_s(VALUE fiber_value) { - const rb_fiber_t *fib = fiber_ptr(fibval); + const rb_fiber_t *fiber = fiber_ptr(fiber_value); const rb_proc_t *proc; char status_info[0x10]; - snprintf(status_info, 0x10, " (%s)", fiber_status_name(fib->status)); - if (!rb_obj_is_proc(fib->first_proc)) { - VALUE str = rb_any_to_s(fibval); + snprintf(status_info, 0x10, " (%s)", fiber_status_name(fiber->status)); + if (!rb_obj_is_proc(fiber->first_proc)) { + VALUE str = rb_any_to_s(fiber_value); strlcat(status_info, ">", sizeof(status_info)); rb_str_set_len(str, RSTRING_LEN(str)-1); rb_str_cat_cstr(str, status_info); return str; } - GetProcPtr(fib->first_proc, proc); - return rb_block_to_s(fibval, &proc->block, status_info); + GetProcPtr(fiber->first_proc, proc); + return rb_block_to_s(fiber_value, &proc->block, status_info); } #ifdef HAVE_WORKING_FORK -- cgit v1.2.3