use previous gaurd

Author: brendandahl

system/lib/pthread/proxying.c

@@ -21,8 +21,6 @@
 struct em_proxying_queue {
   // Protects all accesses to em_task_queues, size, and capacity.
   pthread_mutex_t mutex;
-  // If the mutex is locked this is the thread that is using it.
-  pthread_t active_thread;
   // `size` task queue pointers stored in an array of size `capacity`.
   em_task_queue** task_queues;
   int size;
@@ -32,12 +30,13 @@ struct em_proxying_queue {
 // The system proxying queue.
 static em_proxying_queue system_proxying_queue = {
   .mutex = PTHREAD_MUTEX_INITIALIZER,
-  .active_thread = NULL,
   .task_queues = NULL,
   .size = 0,
   .capacity = 0,
 };
 
+static _Thread_local int system_queue_in_use = 0;
+
 em_proxying_queue* emscripten_proxy_get_system_queue(void) {
   return &system_proxying_queue;
 }
@@ -50,7 +49,6 @@ em_proxying_queue* em_proxying_queue_create(void) {
   }
   *q = (em_proxying_queue){
     .mutex = PTHREAD_MUTEX_INITIALIZER,
-    .active_thread = NULL,
     .task_queues = NULL,
     .size = 0,
     .capacity = 0,
@@ -110,32 +108,28 @@ static em_task_queue* get_or_add_tasks_for_thread(em_proxying_queue* q,
   return tasks;
 }
 
-static _Thread_local bool executing_system_queue = false;
-
 void emscripten_proxy_execute_queue(em_proxying_queue* q) {
   assert(q != NULL);
   assert(pthread_self());
 
-  // Recursion guard to avoid infinite recursion when we arrive here from the
-  // pthread_lock call below that executes the system queue. The per-task_queue
-  // recursion lock can't catch these recursions because it can only be checked
-  // after the lock has been acquired.
-  bool is_system_queue = q == &system_proxying_queue;
-  if (is_system_queue) {
-    if (executing_system_queue) {
-      return;
-    }
-    executing_system_queue = true;
-  }
-
-  // When the current thread is adding tasks it locks the queue, but we can
+  // Below is a recursion and deadlock guard:
+  // The recursion guard is to avoid infinite recursion when we arrive here from
+  // the pthread_lock call below that executes the system queue. The
+  // per-task_queue recursion lock can't catch these recursions because it can
+  // only be checked after the lock has been acquired.
+  // 
+  // This also guards against deadlocks when adding to the system queue. When
+  // the current thread is adding tasks, it locks the queue, but we can
   // potentially try to execute the queue during the add (from
   // emscripten_yield). This will deadlock the thread, so only try to take the
-  // lock if the current thread is not adding to the queue. We then hope the
+  // lock if the current thread is not using the queue. We then hope the
   // queue is executed later when it is unlocked.
-  // XXX: This could leave to starvation if we never process the queue.
-  if (q->active_thread == pthread_self()) {
-    return;
+  int is_system_queue = q == &system_proxying_queue;
+  if (is_system_queue) {
+    if (system_queue_in_use) {
+      return;
+    }
+    system_queue_in_use = true;
   }
 
   pthread_mutex_lock(&q->mutex);
@@ -148,16 +142,21 @@ void emscripten_proxy_execute_queue(em_proxying_queue* q) {
   }
 
   if (is_system_queue) {
-    executing_system_queue = false;
+    system_queue_in_use = false;
   }
 }
 
 static int do_proxy(em_proxying_queue* q, pthread_t target_thread, task t) {
   assert(q != NULL);
   pthread_mutex_lock(&q->mutex);
-  q->active_thread = pthread_self();
+  int is_system_queue = q == &system_proxying_queue;
+  if (is_system_queue) {
+    system_queue_in_use = 1;
+  }
   em_task_queue* tasks = get_or_add_tasks_for_thread(q, target_thread);
-  q->active_thread = NULL;
+  if (is_system_queue) {
+    system_queue_in_use = 0;
+  }
   pthread_mutex_unlock(&q->mutex);
   if (tasks == NULL) {
     return 0;