1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

vm_core.h: rb_thread_struct::machine

Browse Source 
* vm_core.h (rb_thread_struct): aggregate cpu stuff into a struct,
  so that a debugger can show its content at once.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@44722 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
nobu 2014-01-28 06:09:58 +00:00
parent d248a2c96e
commit 628f75b752
7 changed files with 124 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
cont.c
View File

@ -97,16 +97,18 @@ typedef struct rb_context_struct {
size_t vm_stack_slen; /* length of stack (head of th->stack) */ size_t vm_stack_slen; /* length of stack (head of th->stack) */
size_t vm_stack_clen; /* length of control frames (tail of th->stack) */ size_t vm_stack_clen; /* length of control frames (tail of th->stack) */
#endif #endif
VALUE *machine_stack; struct {
VALUE *machine_stack_src; VALUE *stack;
VALUE *stack_src;
size_t stack_size;
#ifdef __ia64 #ifdef __ia64
VALUE *machine_register_stack; VALUE *register_stack;
VALUE *machine_register_stack_src; VALUE *register_stack_src;
int machine_register_stack_size; int register_stack_size;
#endif #endif
} machine;
rb_thread_t saved_thread; rb_thread_t saved_thread;
rb_jmpbuf_t jmpbuf; rb_jmpbuf_t jmpbuf;
size_t machine_stack_size;
rb_ensure_entry_t *ensure_array; rb_ensure_entry_t *ensure_array;
rb_ensure_list_t *ensure_list; rb_ensure_list_t *ensure_list;
} rb_context_t; } rb_context_t;
@ -188,11 +190,11 @@ cont_mark(void *ptr)
#endif #endif
} }
if (cont->machine_stack) { if (cont->machine.stack) {
if (cont->type == CONTINUATION_CONTEXT) { if (cont->type == CONTINUATION_CONTEXT) {
/* cont */ /* cont */
rb_gc_mark_locations(cont->machine_stack, rb_gc_mark_locations(cont->machine.stack,
cont->machine_stack + cont->machine_stack_size); cont->machine.stack + cont->machine.stack_size);
} }
else { else {
/* fiber */ /* fiber */
@ -200,15 +202,15 @@ cont_mark(void *ptr)
rb_fiber_t *fib = (rb_fiber_t*)cont; rb_fiber_t *fib = (rb_fiber_t*)cont;
GetThreadPtr(cont->saved_thread.self, th); GetThreadPtr(cont->saved_thread.self, th);
if ((th->fiber != cont->self) && fib->status == RUNNING) { if ((th->fiber != cont->self) && fib->status == RUNNING) {
rb_gc_mark_locations(cont->machine_stack, rb_gc_mark_locations(cont->machine.stack,
cont->machine_stack + cont->machine_stack_size); cont->machine.stack + cont->machine.stack_size);
} }
} }
} }
#ifdef __ia64 #ifdef __ia64
if (cont->machine_register_stack) { if (cont->machine.register_stack) {
rb_gc_mark_locations(cont->machine_register_stack, rb_gc_mark_locations(cont->machine.register_stack,
cont->machine_register_stack + cont->machine_register_stack_size); cont->machine.register_stack + cont->machine.register_stack_size);
} }
#endif #endif
} }
@ -226,7 +228,7 @@ cont_free(void *ptr)
if (cont->type == CONTINUATION_CONTEXT) { if (cont->type == CONTINUATION_CONTEXT) {
/* cont */ /* cont */
ruby_xfree(cont->ensure_array); ruby_xfree(cont->ensure_array);
RUBY_FREE_UNLESS_NULL(cont->machine_stack); RUBY_FREE_UNLESS_NULL(cont->machine.stack);
} }
else { else {
/* fiber */ /* fiber */
@ -257,10 +259,10 @@ cont_free(void *ptr)
} }
#else /* not FIBER_USE_NATIVE */ #else /* not FIBER_USE_NATIVE */
ruby_xfree(cont->ensure_array); ruby_xfree(cont->ensure_array);
RUBY_FREE_UNLESS_NULL(cont->machine_stack); RUBY_FREE_UNLESS_NULL(cont->machine.stack);
#endif #endif
#ifdef __ia64 #ifdef __ia64
RUBY_FREE_UNLESS_NULL(cont->machine_register_stack); RUBY_FREE_UNLESS_NULL(cont->machine.register_stack);
#endif #endif
RUBY_FREE_UNLESS_NULL(cont->vm_stack); RUBY_FREE_UNLESS_NULL(cont->vm_stack);
@ -286,12 +288,12 @@ cont_memsize(const void *ptr)
size += n * sizeof(*cont->vm_stack); size += n * sizeof(*cont->vm_stack);
} }
if (cont->machine_stack) { if (cont->machine.stack) {
size += cont->machine_stack_size * sizeof(*cont->machine_stack); size += cont->machine.stack_size * sizeof(*cont->machine.stack);
} }
#ifdef __ia64 #ifdef __ia64
if (cont->machine_register_stack) { if (cont->machine.register_stack) {
size += cont->machine_register_stack_size * sizeof(*cont->machine_register_stack); size += cont->machine.register_stack_size * sizeof(*cont->machine.register_stack);
} }
#endif #endif
} }
@ -380,42 +382,42 @@ cont_save_machine_stack(rb_thread_t *th, rb_context_t *cont)
{ {
size_t size; size_t size;
SET_MACHINE_STACK_END(&th->machine_stack_end); SET_MACHINE_STACK_END(&th->machine.stack_end);
#ifdef __ia64 #ifdef __ia64
th->machine_register_stack_end = rb_ia64_bsp(); th->machine.register_stack_end = rb_ia64_bsp();
#endif #endif
if (th->machine_stack_start > th->machine_stack_end) { if (th->machine.stack_start > th->machine.stack_end) {
size = cont->machine_stack_size = th->machine_stack_start - th->machine_stack_end; size = cont->machine.stack_size = th->machine.stack_start - th->machine.stack_end;
cont->machine_stack_src = th->machine_stack_end; cont->machine.stack_src = th->machine.stack_end;
} }
else { else {
size = cont->machine_stack_size = th->machine_stack_end - th->machine_stack_start; size = cont->machine.stack_size = th->machine.stack_end - th->machine.stack_start;
cont->machine_stack_src = th->machine_stack_start; cont->machine.stack_src = th->machine.stack_start;
} }
if (cont->machine_stack) { if (cont->machine.stack) {
REALLOC_N(cont->machine_stack, VALUE, size); REALLOC_N(cont->machine.stack, VALUE, size);
} }
else { else {
cont->machine_stack = ALLOC_N(VALUE, size); cont->machine.stack = ALLOC_N(VALUE, size);
} }
FLUSH_REGISTER_WINDOWS; FLUSH_REGISTER_WINDOWS;
MEMCPY(cont->machine_stack, cont->machine_stack_src, VALUE, size); MEMCPY(cont->machine.stack, cont->machine.stack_src, VALUE, size);
#ifdef __ia64 #ifdef __ia64
rb_ia64_flushrs(); rb_ia64_flushrs();
size = cont->machine_register_stack_size = th->machine_register_stack_end - th->machine_register_stack_start; size = cont->machine.register_stack_size = th->machine.register_stack_end - th->machine.register_stack_start;
cont->machine_register_stack_src = th->machine_register_stack_start; cont->machine.register_stack_src = th->machine.register_stack_start;
if (cont->machine_register_stack) { if (cont->machine.register_stack) {
REALLOC_N(cont->machine_register_stack, VALUE, size); REALLOC_N(cont->machine.register_stack, VALUE, size);
} }
else { else {
cont->machine_register_stack = ALLOC_N(VALUE, size); cont->machine.register_stack = ALLOC_N(VALUE, size);
} }
MEMCPY(cont->machine_register_stack, cont->machine_register_stack_src, VALUE, size); MEMCPY(cont->machine.register_stack, cont->machine.register_stack_src, VALUE, size);
#endif #endif
} }
@ -430,13 +432,13 @@ cont_save_thread(rb_context_t *cont, rb_thread_t *th)
{ {
/* save thread context */ /* save thread context */
cont->saved_thread = *th; cont->saved_thread = *th;
/* saved_thread->machine_stack_(start|end) should be NULL */ /* saved_thread->machine.stack_(start|end) should be NULL */
/* because it may happen GC afterward */ /* because it may happen GC afterward */
cont->saved_thread.machine_stack_start = 0; cont->saved_thread.machine.stack_start = 0;
cont->saved_thread.machine_stack_end = 0; cont->saved_thread.machine.stack_end = 0;
#ifdef __ia64 #ifdef __ia64
cont->saved_thread.machine_register_stack_start = 0; cont->saved_thread.machine.register_stack_start = 0;
cont->saved_thread.machine_register_stack_end = 0; cont->saved_thread.machine.register_stack_end = 0;
#endif #endif
} }
@ -579,7 +581,7 @@ fiber_set_stack_location(void)
VALUE *ptr; VALUE *ptr;
SET_MACHINE_STACK_END(&ptr); SET_MACHINE_STACK_END(&ptr);
th->machine_stack_start = (void*)(((VALUE)ptr & RB_PAGE_MASK) + STACK_UPPER((void *)&ptr, 0, RB_PAGE_SIZE)); th->machine.stack_start = (void*)(((VALUE)ptr & RB_PAGE_MASK) + STACK_UPPER((void *)&ptr, 0, RB_PAGE_SIZE));
} }
static VOID CALLBACK static VOID CALLBACK
@ -654,7 +656,7 @@ fiber_initialize_machine_stack_context(rb_fiber_t *fib, size_t size)
rb_raise(rb_eFiberError, "can't create fiber"); rb_raise(rb_eFiberError, "can't create fiber");
} }
} }
sth->machine_stack_maxsize = size; sth->machine.stack_maxsize = size;
#else /* not WIN32 */ #else /* not WIN32 */
ucontext_t *context = &fib->context; ucontext_t *context = &fib->context;
char *ptr; char *ptr;
@ -666,11 +668,11 @@ fiber_initialize_machine_stack_context(rb_fiber_t *fib, size_t size)
context->uc_stack.ss_sp = ptr; context->uc_stack.ss_sp = ptr;
context->uc_stack.ss_size = size; context->uc_stack.ss_size = size;
makecontext(context, rb_fiber_start, 0); makecontext(context, rb_fiber_start, 0);
sth->machine_stack_start = (VALUE*)(ptr + STACK_DIR_UPPER(0, size)); sth->machine.stack_start = (VALUE*)(ptr + STACK_DIR_UPPER(0, size));
sth->machine_stack_maxsize = size - RB_PAGE_SIZE; sth->machine.stack_maxsize = size - RB_PAGE_SIZE;
#endif #endif
#ifdef __ia64 #ifdef __ia64
sth->machine_register_stack_maxsize = sth->machine_stack_maxsize; sth->machine.register_stack_maxsize = sth->machine.stack_maxsize;
#endif #endif
} }
@ -687,29 +689,29 @@ fiber_setcontext(rb_fiber_t *newfib, rb_fiber_t *oldfib)
/* restore thread context */ /* restore thread context */
cont_restore_thread(&newfib->cont); cont_restore_thread(&newfib->cont);
th->machine_stack_maxsize = sth->machine_stack_maxsize; th->machine.stack_maxsize = sth->machine.stack_maxsize;
if (sth->machine_stack_end && (newfib != oldfib)) { if (sth->machine.stack_end && (newfib != oldfib)) {
rb_bug("fiber_setcontext: sth->machine_stack_end has non zero value"); rb_bug("fiber_setcontext: sth->machine.stack_end has non zero value");
} }
/* save oldfib's machine stack */ /* save oldfib's machine stack */
if (oldfib->status != TERMINATED) { if (oldfib->status != TERMINATED) {
STACK_GROW_DIR_DETECTION; STACK_GROW_DIR_DETECTION;
SET_MACHINE_STACK_END(&th->machine_stack_end); SET_MACHINE_STACK_END(&th->machine.stack_end);
if (STACK_DIR_UPPER(0, 1)) { if (STACK_DIR_UPPER(0, 1)) {
oldfib->cont.machine_stack_size = th->machine_stack_start - th->machine_stack_end; oldfib->cont.machine.stack_size = th->machine.stack_start - th->machine.stack_end;
oldfib->cont.machine_stack = th->machine_stack_end; oldfib->cont.machine.stack = th->machine.stack_end;
} }
else { else {
oldfib->cont.machine_stack_size = th->machine_stack_end - th->machine_stack_start; oldfib->cont.machine.stack_size = th->machine.stack_end - th->machine.stack_start;
oldfib->cont.machine_stack = th->machine_stack_start; oldfib->cont.machine.stack = th->machine.stack_start;
} }
} }
/* exchange machine_stack_start between oldfib and newfib */ /* exchange machine_stack_start between oldfib and newfib */
oldfib->cont.saved_thread.machine_stack_start = th->machine_stack_start; oldfib->cont.saved_thread.machine.stack_start = th->machine.stack_start;
th->machine_stack_start = sth->machine_stack_start; th->machine.stack_start = sth->machine.stack_start;
/* oldfib->machine_stack_end should be NULL */ /* oldfib->machine.stack_end should be NULL */
oldfib->cont.saved_thread.machine_stack_end = 0; oldfib->cont.saved_thread.machine.stack_end = 0;
#ifndef _WIN32 #ifndef _WIN32
if (!newfib->context.uc_stack.ss_sp && th->root_fiber != newfib->cont.self) { if (!newfib->context.uc_stack.ss_sp && th->root_fiber != newfib->cont.self) {
rb_bug("non_root_fiber->context.uc_stac.ss_sp should not be NULL"); rb_bug("non_root_fiber->context.uc_stac.ss_sp should not be NULL");
@ -742,16 +744,16 @@ cont_restore_1(rb_context_t *cont)
((_JUMP_BUFFER*)(&buf))->Frame; ((_JUMP_BUFFER*)(&buf))->Frame;
} }
#endif #endif
if (cont->machine_stack_src) { if (cont->machine.stack_src) {
FLUSH_REGISTER_WINDOWS; FLUSH_REGISTER_WINDOWS;
MEMCPY(cont->machine_stack_src, cont->machine_stack, MEMCPY(cont->machine.stack_src, cont->machine.stack,
VALUE, cont->machine_stack_size); VALUE, cont->machine.stack_size);
} }
#ifdef __ia64 #ifdef __ia64
if (cont->machine_register_stack_src) { if (cont->machine.register_stack_src) {
MEMCPY(cont->machine_register_stack_src, cont->machine_register_stack, MEMCPY(cont->machine.register_stack_src, cont->machine.register_stack,
VALUE, cont->machine_register_stack_size); VALUE, cont->machine.register_stack_size);
} }
#endif #endif
@ -786,7 +788,7 @@ register_stack_extend(rb_context_t *cont, VALUE *vp, VALUE *curr_bsp)
E(k) = E(l) = E(m) = E(n) = E(o) = E(k) = E(l) = E(m) = E(n) = E(o) =
E(p) = E(q) = E(r) = E(s) = E(t) = 0; E(p) = E(q) = E(r) = E(s) = E(t) = 0;
} }
if (curr_bsp < cont->machine_register_stack_src+cont->machine_register_stack_size) { if (curr_bsp < cont->machine.register_stack_src+cont->machine.register_stack_size) {
register_stack_extend(cont, vp, (VALUE*)rb_ia64_bsp()); register_stack_extend(cont, vp, (VALUE*)rb_ia64_bsp());
} }
cont_restore_0(cont, vp); cont_restore_0(cont, vp);
@ -798,7 +800,7 @@ register_stack_extend(rb_context_t *cont, VALUE *vp, VALUE *curr_bsp)
static void static void
cont_restore_0(rb_context_t *cont, VALUE *addr_in_prev_frame) cont_restore_0(rb_context_t *cont, VALUE *addr_in_prev_frame)
{ {
if (cont->machine_stack_src) { if (cont->machine.stack_src) {
#ifdef HAVE_ALLOCA #ifdef HAVE_ALLOCA
#define STACK_PAD_SIZE 1 #define STACK_PAD_SIZE 1
#else #else
@ -811,7 +813,7 @@ cont_restore_0(rb_context_t *cont, VALUE *addr_in_prev_frame)
/* Stack grows downward */ /* Stack grows downward */
#endif #endif
#if STACK_GROW_DIRECTION <= 0 #if STACK_GROW_DIRECTION <= 0
volatile VALUE *const end = cont->machine_stack_src; volatile VALUE *const end = cont->machine.stack_src;
if (&space[0] > end) { if (&space[0] > end) {
# ifdef HAVE_ALLOCA # ifdef HAVE_ALLOCA
volatile VALUE *sp = ALLOCA_N(VALUE, &space[0] - end); volatile VALUE *sp = ALLOCA_N(VALUE, &space[0] - end);
@ -827,7 +829,7 @@ cont_restore_0(rb_context_t *cont, VALUE *addr_in_prev_frame)
/* Stack grows upward */ /* Stack grows upward */
#endif #endif
#if STACK_GROW_DIRECTION >= 0 #if STACK_GROW_DIRECTION >= 0
volatile VALUE *const end = cont->machine_stack_src + cont->machine_stack_size; volatile VALUE *const end = cont->machine.stack_src + cont->machine.stack_size;
if (&space[STACK_PAD_SIZE] < end) { if (&space[STACK_PAD_SIZE] < end) {
# ifdef HAVE_ALLOCA # ifdef HAVE_ALLOCA
volatile VALUE *sp = ALLOCA_N(VALUE, end - &space[STACK_PAD_SIZE]); volatile VALUE *sp = ALLOCA_N(VALUE, end - &space[STACK_PAD_SIZE]);
@ -1258,8 +1260,8 @@ rb_fiber_terminate(rb_fiber_t *fib)
terminated_machine_stack.ptr = fib->context.uc_stack.ss_sp; terminated_machine_stack.ptr = fib->context.uc_stack.ss_sp;
terminated_machine_stack.size = fib->context.uc_stack.ss_size / sizeof(VALUE); terminated_machine_stack.size = fib->context.uc_stack.ss_size / sizeof(VALUE);
fib->context.uc_stack.ss_sp = NULL; fib->context.uc_stack.ss_sp = NULL;
fib->cont.machine_stack = NULL; fib->cont.machine.stack = NULL;
fib->cont.machine_stack_size = 0; fib->cont.machine.stack_size = 0;
#endif #endif
rb_fiber_transfer(return_fiber(), 1, &value); rb_fiber_transfer(return_fiber(), 1, &value);
} }
@ -1369,7 +1371,7 @@ fiber_store(rb_fiber_t *next_fib)
machine_stack_cache_index++; machine_stack_cache_index++;
} }
else { else {
if (terminated_machine_stack.ptr != fib->cont.machine_stack) { if (terminated_machine_stack.ptr != fib->cont.machine.stack) {
munmap((void*)terminated_machine_stack.ptr, terminated_machine_stack.size * sizeof(VALUE)); munmap((void*)terminated_machine_stack.ptr, terminated_machine_stack.size * sizeof(VALUE));
} }
else { else {
@ -1659,7 +1661,7 @@ Init_Cont(void)
#else /* not WIN32 */ #else /* not WIN32 */
pagesize = sysconf(_SC_PAGESIZE); pagesize = sysconf(_SC_PAGESIZE);
#endif #endif
SET_MACHINE_STACK_END(&th->machine_stack_end); SET_MACHINE_STACK_END(&th->machine.stack_end);
#endif #endif
rb_cFiber = rb_define_class("Fiber", rb_cObject); rb_cFiber = rb_define_class("Fiber", rb_cObject);

18
gc.c
View File

@ -3209,14 +3209,14 @@ init_mark_stack(mark_stack_t *stack)
/* Marking */ /* Marking */
#ifdef __ia64 #ifdef __ia64
#define SET_STACK_END (SET_MACHINE_STACK_END(&th->machine_stack_end), th->machine_register_stack_end = rb_ia64_bsp()) #define SET_STACK_END (SET_MACHINE_STACK_END(&th->machine.stack_end), th->machine.register_stack_end = rb_ia64_bsp())
#else #else
#define SET_STACK_END SET_MACHINE_STACK_END(&th->machine_stack_end) #define SET_STACK_END SET_MACHINE_STACK_END(&th->machine.stack_end)
#endif #endif
#define STACK_START (th->machine_stack_start) #define STACK_START (th->machine.stack_start)
#define STACK_END (th->machine_stack_end) #define STACK_END (th->machine.stack_end)
#define STACK_LEVEL_MAX (th->machine_stack_maxsize/sizeof(VALUE)) #define STACK_LEVEL_MAX (th->machine.stack_maxsize/sizeof(VALUE))
#if STACK_GROW_DIRECTION < 0 #if STACK_GROW_DIRECTION < 0
# define STACK_LENGTH (size_t)(STACK_START - STACK_END) # define STACK_LENGTH (size_t)(STACK_START - STACK_END)
@ -3258,8 +3258,8 @@ stack_check(int water_mark)
ret = STACK_LENGTH > STACK_LEVEL_MAX - water_mark; ret = STACK_LENGTH > STACK_LEVEL_MAX - water_mark;
#ifdef __ia64 #ifdef __ia64
if (!ret) { if (!ret) {
ret = (VALUE*)rb_ia64_bsp() - th->machine_register_stack_start > ret = (VALUE*)rb_ia64_bsp() - th->machine.register_stack_start >
th->machine_register_stack_maxsize/sizeof(VALUE) - water_mark; th->machine.register_stack_maxsize/sizeof(VALUE) - water_mark;
} }
#endif #endif
return ret; return ret;
@ -3483,7 +3483,7 @@ mark_current_machine_context(rb_objspace_t *objspace, rb_thread_t *th)
rb_gc_mark_locations(stack_start, stack_end); rb_gc_mark_locations(stack_start, stack_end);
#ifdef __ia64 #ifdef __ia64
rb_gc_mark_locations(th->machine_register_stack_start, th->machine_register_stack_end); rb_gc_mark_locations(th->machine.register_stack_start, th->machine.register_stack_end);
#endif #endif
#if defined(__mc68000__) #if defined(__mc68000__)
mark_locations_array(objspace, (VALUE*)((char*)STACK_END + 2), mark_locations_array(objspace, (VALUE*)((char*)STACK_END + 2),
@ -3500,7 +3500,7 @@ rb_gc_mark_machine_stack(rb_thread_t *th)
GET_STACK_BOUNDS(stack_start, stack_end, 0); GET_STACK_BOUNDS(stack_start, stack_end, 0);
rb_gc_mark_locations(stack_start, stack_end); rb_gc_mark_locations(stack_start, stack_end);
#ifdef __ia64 #ifdef __ia64
rb_gc_mark_locations(th->machine_register_stack_start, th->machine_register_stack_end); rb_gc_mark_locations(th->machine.register_stack_start, th->machine.register_stack_end);
#endif #endif
} }

14
thread.c
View File

@ -121,7 +121,7 @@ static inline void blocking_region_end(rb_thread_t *th, struct rb_blocking_regio
#ifdef __ia64 #ifdef __ia64
#define RB_GC_SAVE_MACHINE_REGISTER_STACK(th) \ #define RB_GC_SAVE_MACHINE_REGISTER_STACK(th) \
do{(th)->machine_register_stack_end = rb_ia64_bsp();}while(0) do{(th)->machine.register_stack_end = rb_ia64_bsp();}while(0)
#else #else
#define RB_GC_SAVE_MACHINE_REGISTER_STACK(th) #define RB_GC_SAVE_MACHINE_REGISTER_STACK(th)
#endif #endif
@ -129,8 +129,8 @@ static inline void blocking_region_end(rb_thread_t *th, struct rb_blocking_regio
do { \ do { \
FLUSH_REGISTER_WINDOWS; \ FLUSH_REGISTER_WINDOWS; \
RB_GC_SAVE_MACHINE_REGISTER_STACK(th); \ RB_GC_SAVE_MACHINE_REGISTER_STACK(th); \
setjmp((th)->machine_regs); \ setjmp((th)->machine.regs); \
SET_MACHINE_STACK_END(&(th)->machine_stack_end); \ SET_MACHINE_STACK_END(&(th)->machine.stack_end); \
} while (0) } while (0)
#define GVL_UNLOCK_BEGIN() do { \ #define GVL_UNLOCK_BEGIN() do { \
@ -465,9 +465,9 @@ thread_cleanup_func_before_exec(void *th_ptr)
{ {
rb_thread_t *th = th_ptr; rb_thread_t *th = th_ptr;
th->status = THREAD_KILLED; th->status = THREAD_KILLED;
th->machine_stack_start = th->machine_stack_end = 0; th->machine.stack_start = th->machine.stack_end = 0;
#ifdef __ia64 #ifdef __ia64
th->machine_register_stack_start = th->machine_register_stack_end = 0; th->machine.register_stack_start = th->machine.register_stack_end = 0;
#endif #endif
} }
@ -519,9 +519,9 @@ thread_start_func_2(rb_thread_t *th, VALUE *stack_start, VALUE *register_stack_s
ruby_thread_set_native(th); ruby_thread_set_native(th);
th->machine_stack_start = stack_start; th->machine.stack_start = stack_start;
#ifdef __ia64 #ifdef __ia64
th->machine_register_stack_start = register_stack_start; th->machine.register_stack_start = register_stack_start;
#endif #endif
thread_debug("thread start: %p\n", (void *)th); thread_debug("thread start: %p\n", (void *)th);

32
thread_pthread.c
View File

@ -749,8 +749,8 @@ native_thread_init_stack(rb_thread_t *th)
rb_nativethread_id_t curr = pthread_self(); rb_nativethread_id_t curr = pthread_self();
if (pthread_equal(curr, native_main_thread.id)) { if (pthread_equal(curr, native_main_thread.id)) {
th->machine_stack_start = native_main_thread.stack_start; th->machine.stack_start = native_main_thread.stack_start;
th->machine_stack_maxsize = native_main_thread.stack_maxsize; th->machine.stack_maxsize = native_main_thread.stack_maxsize;
} }
else { else {
#ifdef STACKADDR_AVAILABLE #ifdef STACKADDR_AVAILABLE
@ -758,11 +758,11 @@ native_thread_init_stack(rb_thread_t *th)
size_t size; size_t size;
if (get_stack(&start, &size) == 0) { if (get_stack(&start, &size) == 0) {
th->machine_stack_start = start; th->machine.stack_start = start;
th->machine_stack_maxsize = size; th->machine.stack_maxsize = size;
} }
#elif defined get_stack_of #elif defined get_stack_of
if (!th->machine_stack_maxsize) { if (!th->machine.stack_maxsize) {
native_mutex_lock(&th->interrupt_lock); native_mutex_lock(&th->interrupt_lock);
native_mutex_unlock(&th->interrupt_lock); native_mutex_unlock(&th->interrupt_lock);
} }
@ -771,9 +771,9 @@ native_thread_init_stack(rb_thread_t *th)
#endif #endif
} }
#ifdef __ia64 #ifdef __ia64
th->machine_register_stack_start = native_main_thread.register_stack_start; th->machine.register_stack_start = native_main_thread.register_stack_start;
th->machine_stack_maxsize /= 2; th->machine.stack_maxsize /= 2;
th->machine_register_stack_maxsize = th->machine_stack_maxsize; th->machine.register_stack_maxsize = th->machine.stack_maxsize;
#endif #endif
return 0; return 0;
} }
@ -800,7 +800,7 @@ thread_start_func_1(void *th_ptr)
native_thread_init(th); native_thread_init(th);
/* run */ /* run */
#if defined USE_NATIVE_THREAD_INIT #if defined USE_NATIVE_THREAD_INIT
thread_start_func_2(th, th->machine_stack_start, rb_ia64_bsp()); thread_start_func_2(th, th->machine.stack_start, rb_ia64_bsp());
#else #else
thread_start_func_2(th, &stack_start, rb_ia64_bsp()); thread_start_func_2(th, &stack_start, rb_ia64_bsp());
#endif #endif
@ -922,10 +922,10 @@ native_thread_create(rb_thread_t *th)
const size_t stack_size = th->vm->default_params.thread_machine_stack_size; const size_t stack_size = th->vm->default_params.thread_machine_stack_size;
const size_t space = space_size(stack_size); const size_t space = space_size(stack_size);
th->machine_stack_maxsize = stack_size - space; th->machine.stack_maxsize = stack_size - space;
#ifdef __ia64 #ifdef __ia64
th->machine_stack_maxsize /= 2; th->machine.stack_maxsize /= 2;
th->machine_register_stack_maxsize = th->machine_stack_maxsize; th->machine.register_stack_maxsize = th->machine.stack_maxsize;
#endif #endif
#ifdef HAVE_PTHREAD_ATTR_INIT #ifdef HAVE_PTHREAD_ATTR_INIT
@ -948,8 +948,8 @@ native_thread_create(rb_thread_t *th)
#ifdef get_stack_of #ifdef get_stack_of
if (!err) { if (!err) {
get_stack_of(th->thread_id, get_stack_of(th->thread_id,
&th->machine_stack_start, &th->machine.stack_start,
&th->machine_stack_maxsize); &th->machine.stack_maxsize);
} }
native_mutex_unlock(&th->interrupt_lock); native_mutex_unlock(&th->interrupt_lock);
#endif #endif
@ -1561,7 +1561,7 @@ ruby_stack_overflowed_p(const rb_thread_t *th, const void *addr)
STACK_GROW_DIR_DETECTION; STACK_GROW_DIR_DETECTION;
if (th) { if (th) {
size = th->machine_stack_maxsize; size = th->machine.stack_maxsize;
#if defined(HAVE_GETRLIMIT) && MAINSTACKADDR_AVAILABLE #if defined(HAVE_GETRLIMIT) && MAINSTACKADDR_AVAILABLE
if (pthread_equal(th->thread_id, native_main_thread.id)) { if (pthread_equal(th->thread_id, native_main_thread.id)) {
struct rlimit rlim; struct rlimit rlim;
@ -1570,7 +1570,7 @@ ruby_stack_overflowed_p(const rb_thread_t *th, const void *addr)
} }
} }
#endif #endif
base = (char *)th->machine_stack_start - STACK_DIR_UPPER(0, size); base = (char *)th->machine.stack_start - STACK_DIR_UPPER(0, size);
} }
#ifdef STACKADDR_AVAILABLE #ifdef STACKADDR_AVAILABLE
else if (get_stack(&base, &size) == 0) { else if (get_stack(&base, &size) == 0) {

6
thread_win32.c
View File

@ -571,8 +571,8 @@ native_thread_init_stack(rb_thread_t *th)
size = end - base; size = end - base;
space = size / 5; space = size / 5;
if (space > 1024*1024) space = 1024*1024; if (space > 1024*1024) space = 1024*1024;
th->machine_stack_start = (VALUE *)end - 1; th->machine.stack_start = (VALUE *)end - 1;
th->machine_stack_maxsize = size - space; th->machine.stack_maxsize = size - space;
} }
#ifndef InterlockedExchangePointer #ifndef InterlockedExchangePointer
@ -600,7 +600,7 @@ thread_start_func_1(void *th_ptr)
thread_debug("thread created (th: %p, thid: %p, event: %p)\n", th, thread_debug("thread created (th: %p, thid: %p, event: %p)\n", th,
th->thread_id, th->native_thread_data.interrupt_event); th->thread_id, th->native_thread_data.interrupt_event);
thread_start_func_2(th, th->machine_stack_start, rb_ia64_bsp()); thread_start_func_2(th, th->machine.stack_start, rb_ia64_bsp());
w32_close_handle(thread_id); w32_close_handle(thread_id);
thread_debug("thread deleted (th: %p)\n", th); thread_debug("thread deleted (th: %p)\n", th);

8
vm.c
View File

@ -1987,11 +1987,11 @@ rb_thread_mark(void *ptr)
rb_mark_tbl(th->local_storage); rb_mark_tbl(th->local_storage);
if (GET_THREAD() != th && th->machine_stack_start && th->machine_stack_end) { if (GET_THREAD() != th && th->machine.stack_start && th->machine.stack_end) {
rb_gc_mark_machine_stack(th); rb_gc_mark_machine_stack(th);
rb_gc_mark_locations((VALUE *)&th->machine_regs, rb_gc_mark_locations((VALUE *)&th->machine.regs,
(VALUE *)(&th->machine_regs) + (VALUE *)(&th->machine.regs) +
sizeof(th->machine_regs) / sizeof(VALUE)); sizeof(th->machine.regs) / sizeof(VALUE));
} }
rb_vm_trace_mark_event_hooks(&th->event_hooks); rb_vm_trace_mark_event_hooks(&th->event_hooks);

16
vm_core.h
View File

@ -617,15 +617,17 @@ typedef struct rb_thread_struct {
VALUE (*first_func)(ANYARGS); VALUE (*first_func)(ANYARGS);
/* for GC */ /* for GC */
VALUE *machine_stack_start; struct {
VALUE *machine_stack_end; VALUE *stack_start;
size_t machine_stack_maxsize; VALUE *stack_end;
size_t stack_maxsize;
#ifdef __ia64 #ifdef __ia64
VALUE *machine_register_stack_start; VALUE *register_stack_start;
VALUE *machine_register_stack_end; VALUE *register_stack_end;
size_t machine_register_stack_maxsize; size_t register_stack_maxsize;
#endif #endif
jmp_buf machine_regs; jmp_buf regs;
} machine;
int mark_stack_len; int mark_stack_len;
/* statistics data for profiler */ /* statistics data for profiler */