From f5b15f0e3f6d3f3b3467059802e24c8de0d9d361 Mon Sep 17 00:00:00 2001 From: ko1 Date: Tue, 22 Oct 2013 06:24:54 +0000 Subject: * vm_trace.c: exterminate Zombies. There is a bug that T_ZOMBIE objects are not collected. Because there is a pass to miss finalizer postponed job with multi-threading. This patch solve this issue. * vm_trace.c (rb_postponed_job_register_one): set RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(th) if another same job is registered. There is a possibility to remain a postponed job without interrupt flag. * vm_trace.c (rb_postponed_job_register_one): check interrupt carefully. * vm_trace.c (rb_postponed_job_register_one): use additional space to avoid buffer full. * gc.c (gc_finalize_deferred_register): check failure. * thread.c (rb_threadptr_execute_interrupts): check `postponed_job_interrupt' immediately. There is a possibility to miss this flag. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@43383 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ChangeLog | 25 +++++++++++++++++++++++ gc.c | 4 +++- thread.c | 8 ++++---- vm_trace.c | 69 ++++++++++++++++++++++++++++++++++++++++++++------------------ 4 files changed, 81 insertions(+), 25 deletions(-) diff --git a/ChangeLog b/ChangeLog index d8f1982731..d6b5d5777b 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,28 @@ +Tue Oct 22 14:53:11 2013 Koichi Sasada + + * vm_trace.c: exterminate Zombies. + There is a bug that T_ZOMBIE objects are not collected. + Because there is a pass to miss finalizer postponed job + with multi-threading. This patch solve this issue. + + * vm_trace.c (rb_postponed_job_register_one): set + RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(th) if another same job + is registered. + There is a possibility to remain a postponed job without + interrupt flag. + + * vm_trace.c (rb_postponed_job_register_one): check interrupt + carefully. + + * vm_trace.c (rb_postponed_job_register_one): use additional space + to avoid buffer full. + + * gc.c (gc_finalize_deferred_register): check failure. + + * thread.c (rb_threadptr_execute_interrupts): check + `postponed_job_interrupt' immediately. There is a possibility + to miss this flag. + Tue Oct 22 12:11:16 2013 Nobuyoshi Nakada * configure.in: check if the given CFLAGS and LDFLAGS are working, and diff --git a/gc.c b/gc.c index 634ba0d41c..b25e532014 100644 --- a/gc.c +++ b/gc.c @@ -1821,7 +1821,9 @@ rb_gc_finalize_deferred(void) static void gc_finalize_deferred_register() { - rb_postponed_job_register_one(0, gc_finalize_deferred, 0); + if (rb_postponed_job_register_one(0, gc_finalize_deferred, 0) == 0) { + rb_bug("gc_finalize_deferred_register: can't register finalizer."); + } } struct force_finalize_list { diff --git a/thread.c b/thread.c index 11ec96ea6c..f33e630afb 100644 --- a/thread.c +++ b/thread.c @@ -1956,6 +1956,10 @@ rb_threadptr_execute_interrupts(rb_thread_t *th, int blocking_timing) postponed_job_interrupt = interrupt & POSTPONED_JOB_INTERRUPT_MASK; trap_interrupt = interrupt & TRAP_INTERRUPT_MASK; + if (postponed_job_interrupt) { + rb_postponed_job_flush(th->vm); + } + /* signal handling */ if (trap_interrupt && (th == th->vm->main_thread)) { enum rb_thread_status prev_status = th->status; @@ -2004,10 +2008,6 @@ rb_threadptr_execute_interrupts(rb_thread_t *th, int blocking_timing) rb_thread_schedule_limits(limits_us); } } - - if (postponed_job_interrupt) { - rb_postponed_job_flush(th->vm); - } } void diff --git a/vm_trace.c b/vm_trace.c index 0e09c7e310..2371846580 100644 --- a/vm_trace.c +++ b/vm_trace.c @@ -1385,7 +1385,8 @@ typedef struct rb_postponed_job_struct { void *data; } rb_postponed_job_t; -#define MAX_POSTPONED_JOB 1024 +#define MAX_POSTPONED_JOB 1000 +#define MAX_POSTPONED_JOB_SPECIAL_ADDITION 24 static void Init_postponed_job(void) @@ -1395,22 +1396,25 @@ Init_postponed_job(void) vm->postponed_job_index = 0; } -/* return 0 if job buffer is full */ -int -rb_postponed_job_register(unsigned int flags, rb_postponed_job_func_t func, void *data) +enum postponed_job_register_result { + PJRR_SUCESS = 0, + PJRR_FULL = 1, + PJRR_INTERRUPTED = 2 +}; + +static enum postponed_job_register_result +postponed_job_register(rb_thread_t *th, rb_vm_t *vm, + unsigned int flags, rb_postponed_job_func_t func, void *data, int max, int expected_index) { - rb_thread_t *th = GET_THREAD(); - rb_vm_t *vm = th->vm; rb_postponed_job_t *pjob; - while (1) { - int index = vm->postponed_job_index; - if (index >= MAX_POSTPONED_JOB) return 0; /* failed */ + if (expected_index >= max) return PJRR_FULL; /* failed */ - if (ATOMIC_CAS(vm->postponed_job_index, index, index+1) == index) { - pjob = &vm->postponed_job_buffer[index]; - break; - } + if (ATOMIC_CAS(vm->postponed_job_index, expected_index, expected_index+1) == expected_index) { + pjob = &vm->postponed_job_buffer[expected_index]; + } + else { + return PJRR_INTERRUPTED; } pjob->flags = flags; @@ -1420,25 +1424,50 @@ rb_postponed_job_register(unsigned int flags, rb_postponed_job_func_t func, void RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(th); - return 1; + return PJRR_SUCESS; +} + + +/* return 0 if job buffer is full */ +int +rb_postponed_job_register(unsigned int flags, rb_postponed_job_func_t func, void *data) +{ + rb_thread_t *th = GET_THREAD(); + rb_vm_t *vm = th->vm; + + begin: + switch (postponed_job_register(th, vm, flags, func, data, MAX_POSTPONED_JOB, vm->postponed_job_index)) { + case PJRR_SUCESS : return 1; + case PJRR_FULL : return 0; + case PJRR_INTERRUPTED: goto begin; + default: rb_bug("unreachable\n"); + } } +/* return 0 if job buffer is full */ int rb_postponed_job_register_one(unsigned int flags, rb_postponed_job_func_t func, void *data) { - rb_vm_t *vm = GET_VM(); + rb_thread_t *th = GET_THREAD(); + rb_vm_t *vm = th->vm; rb_postponed_job_t *pjob; - int i; + int i, index; - /* TODO: this check is not signal safe, but I believe this is not critical prbolem */ - for (i=0; ipostponed_job_index; i++) { + begin: + index = vm->postponed_job_index; + for (i=0; ipostponed_job_buffer[i]; if (pjob->func == func) { + RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(th); return 2; } } - - return rb_postponed_job_register(flags, func, data); + switch (postponed_job_register(th, vm, flags, func, data, MAX_POSTPONED_JOB + MAX_POSTPONED_JOB_SPECIAL_ADDITION, index)) { + case PJRR_SUCESS : return 1; + case PJRR_FULL : return 0; + case PJRR_INTERRUPTED: goto begin; + default: rb_bug("unreachable\n"); + } } void -- cgit v1.2.3