add pruning of dead pthreads

Author: mattip

src/vmprof_common.c

@@ -229,7 +229,7 @@ ssize_t insert_thread(pthread_t tid, ssize_t i)
 {
     assert(signal_type == SIGALRM);
     i = search_thread(tid, i);
-    if (i > 0)
+    if (i >= 0)
         return -1;
     if (thread_count == threads_size) {
         threads_size += threads_size_step;
@@ -268,6 +268,45 @@ ssize_t remove_threads(void)
     return 0;
 }
 
+#ifndef RPYTHON_VMPROF
+static int python_thread_is_alive(pthread_t tid)
+{
+    unsigned long ident = (unsigned long)tid; /* as PyThread_get_thread_ident */
+    PyInterpreterState *istate = PyInterpreterState_Head();
+    PyThreadState *state;
+    while (istate != NULL) {
+        state = PyInterpreterState_ThreadHead(istate);
+        while (state != NULL) {
+            if (state->thread_id == ident)
+                return 1;
+            state = PyThreadState_Next(state);
+        }
+        istate = PyInterpreterState_Next(istate);
+    }
+    return 0;
+}
+
+void prune_dead_threads(void)
+{
+    /* pthread_kill() on a thread that has exited and been joined is
+       undefined behaviour, and segfaults on glibc because the thread
+       descriptor lives on the thread's freed stack.  Nothing removes an
+       exited thread from 'threads' by itself, so before broadcasting drop
+       every registered thread whose Python thread state is gone: CPython
+       deletes it before the thread exits.  Called from the signal handler,
+       under the spinlock and the SIGSEGV guard that also protects the
+       thread state lookup. */
+    size_t i = 0;
+    while (i < thread_count) {
+        if (python_thread_is_alive(threads[i])) {
+            i++;
+        } else {
+            remove_thread(threads[i], i);
+        }
+    }
+}
+#endif
+
 int broadcast_signal_for_threads(void)
 {
     int done = 1;
@@ -279,7 +318,9 @@ int broadcast_signal_for_threads(void)
         if (pthread_equal(tid, self)) {
             done = 0;
         } else if (pthread_kill(tid, SIGALRM)) {
+            /* the last entry is moved into slot i, look at it next */
             remove_thread(tid, i);
+            continue;
         }
         i++;
     }

src/vmprof_common.h

@@ -101,4 +101,7 @@ int vmprof_get_itimer_type(void);
 #ifdef VMPROF_UNIX
 int broadcast_signal_for_threads(void);
 int is_main_thread(void);
+#ifndef RPYTHON_VMPROF
+void prune_dead_threads(void);
+#endif
 #endif

src/vmprof_unix.c

@@ -207,23 +207,25 @@ void sigprof_handler(int sig_nr, siginfo_t* info, void *ucontext)
     while (__sync_lock_test_and_set(&spinlock, 1)) {
     }
 
-#ifdef VMPROF_UNIX
     // SIGNAL ABUSE AHEAD
     // On linux, the prof timer will deliver the signal to the thread which triggered the timer,
     // because these timers are based on process and system time, and as such, are thread-aware.
     // For the real timer, the signal gets delivered to the main thread, seemingly always.
     // Consequently if we want to sample multiple threads, we need to forward this signal.
-    if (vmprof_get_signal_type() == SIGALRM) {
-        if (is_main_thread() && broadcast_signal_for_threads()) {
-            __sync_lock_release(&spinlock);
-            return;
-        }
-    }
+    int broadcast = 0;
+#ifdef VMPROF_UNIX
+    broadcast = (vmprof_get_signal_type() == SIGALRM) && is_main_thread();
 #endif
 
     prevhandler = signal(SIGSEGV, &segfault_handler);
     int fault_code = setjmp(restore_point);
     if (fault_code == 0) {
+#ifdef VMPROF_UNIX
+        if (broadcast) {
+            // walks the thread states, hence inside the guard
+            prune_dead_threads();
+        }
+#endif
         pthread_self();
         tstate = _get_pystate_for_this_thread();
     } else {
@@ -232,6 +234,14 @@ void sigprof_handler(int sig_nr, siginfo_t* info, void *ucontext)
         return;
     }
     signal(SIGSEGV, prevhandler);
+
+#ifdef VMPROF_UNIX
+    if (broadcast && broadcast_signal_for_threads()) {
+        // the main thread itself is not registered: forwarded only
+        __sync_lock_release(&spinlock);
+        return;
+    }
+#endif
     __sync_lock_release(&spinlock);
 #endif
 

vmprof/test/test_run.py

@@ -323,7 +323,6 @@ def test_insert_other_real_time_thread(insert_foo, remove_bar):
 
 @pytest.mark.skipif("'__pypy__' in sys.builtin_module_names")
 @pytest.mark.skipif("sys.platform == 'win32'")
-@pytest.mark.skip("seems to crash")
 def test_vmprof_real_time_many_threads():
     import threading
     prof = vmprof.Profiler()