WIP: fix zombie thread issue

ractor.c

@@ -2273,13 +2273,17 @@ ractor_check_blocking(rb_ractor_t *cr, unsigned int remained_thread_cnt, const c
     }
 }
 
+void rb_threadptr_remove(rb_thread_t *th);
+
 void
 rb_ractor_living_threads_remove(rb_ractor_t *cr, rb_thread_t *th)
 {
     VM_ASSERT(cr == GET_RACTOR());
     RUBY_DEBUG_LOG("r->threads.cnt:%d--", cr->threads.cnt);
     ractor_check_blocking(cr, cr->threads.cnt - 1, __FILE__, __LINE__);
 
+    rb_threadptr_remove(th);
+
     if (cr->threads.cnt == 1) {
         vm_remove_ractor(th->vm, cr);
     }

thread_pthread.c

@@ -2236,9 +2236,32 @@ static int native_thread_create_shared(rb_thread_t *th);
 static void nt_free_stack(void *mstack);
 #endif
 
+void
+rb_threadptr_remove(rb_thread_t *th)
+{
+#if USE_MN_THREADS
+    if (th->sched.malloc_stack) {
+        // dedicated
+        return;
+    }
+    else {
+        rb_vm_t *vm = th->vm;
+        th->sched.finished = false;
+
+        RB_VM_LOCK_ENTER();
+        {
+            ccan_list_add(&vm->ractor.sched.zombie_threads, &th->sched.node.zombie_threads);
+        }
+        RB_VM_LOCK_LEAVE();
+    }
+#endif
+}
+
 void
 rb_threadptr_sched_free(rb_thread_t *th)
 {
+    fprintf(stderr, "rb_threadptr_sched_free th:%p\n", th);
+
 #if USE_MN_THREADS
     if (th->sched.malloc_stack) {
         ruby_xfree(th->sched.context_stack);
@@ -2255,6 +2278,8 @@ rb_threadptr_sched_free(rb_thread_t *th)
         ruby_xfree(th->sched.context);
         VM_ASSERT((th->sched.context = NULL) == NULL);
     }
+
+    th->nt = NULL;
 #else
     ruby_xfree(th->sched.context_stack);
 

thread_pthread.h

@@ -33,6 +33,9 @@ struct rb_thread_sched_item {
         // connected to vm->ractor.sched.running_threads
         // locked by vm->ractor.sched.lock
         struct ccan_list_node running_threads;
+
+        // connected to vm->ractor.sched.zombie_threads
+        struct ccan_list_node zombie_threads;
     } node;
 
     // this data should be protected by timer_th.waiting_lock
@@ -60,6 +63,7 @@ struct rb_thread_sched_item {
         struct ccan_list_node node;
     } waiting_reason;
 
+    bool finished;
     bool malloc_stack;
     void *context_stack;
     struct coroutine_context *context;

thread_pthread_mn.c

@@ -420,17 +420,19 @@ co_start(struct coroutine_context *from, struct coroutine_context *self)
     bool has_ready_ractor = vm->ractor.sched.grq_cnt > 0; // at least this ractor is not queued
 
     rb_thread_t *next_th = sched->running;
+    struct rb_native_thread *nt = th->nt;
+    native_thread_assign(NULL, th);
+    rb_ractor_set_current_ec(th->ractor, NULL);
+
     if (!has_ready_ractor && next_th && !next_th->nt) {
         // switch to the next thread
         thread_sched_set_lock_owner(sched, NULL);
-        rb_ractor_set_current_ec(th->ractor, NULL);
-        thread_sched_switch(th, next_th);
+        thread_sched_switch0(th->sched.context, next_th, nt);
+        th->sched.finished = true;
     }
     else {
-        struct rb_native_thread *nt = th->nt;
         // switch to the next Ractor
-        rb_ractor_set_current_ec(th->ractor, NULL);
-        native_thread_assign(NULL, th);
+        th->sched.finished = true;
         coroutine_transfer(self, nt->nt_context);
     }
     rb_bug("unreachable");

vm.c

@@ -2884,6 +2884,18 @@ rb_vm_mark(void *ptr)
             }
         }
 
+        if (!ccan_list_empty(&vm->ractor.sched.zombie_threads)) {
+            rb_thread_t *zombie_th, *next_zombie_th;
+            ccan_list_for_each_safe(&vm->ractor.sched.zombie_threads, zombie_th, next_zombie_th, sched.node.zombie_threads) {
+                if (zombie_th->sched.finished) {
+                    ccan_list_del_init(&zombie_th->sched.node.zombie_threads);
+                }
+                else {
+                    rb_gc_mark(zombie_th->self);
+                }
+            }
+        }
+
         rb_rjit_mark();
     }
 

vm_core.h

@@ -667,6 +667,8 @@ typedef struct rb_vm_struct {
             // threads which switch context by timeslice
             struct ccan_list_head timeslice_threads;
 
+            struct ccan_list_head zombie_threads;
+
             // true if timeslice timer is not enable
             bool timeslice_wait_inf;
 
@@ -1773,6 +1775,7 @@ rb_vm_living_threads_init(rb_vm_t *vm)
     ccan_list_head_init(&vm->waiting_fds);
     ccan_list_head_init(&vm->workqueue);
     ccan_list_head_init(&vm->ractor.set);
+    ccan_list_head_init(&vm->ractor.sched.zombie_threads);
 }
 
 typedef int rb_backtrace_iter_func(void *, VALUE, int, VALUE);