Function emscripten_proxy_execute_queue

system/lib/pthread/proxying.c:111–147

}

void emscripten_proxy_execute_queue(em_proxying_queue* q) {
  assert(q != NULL);
  assert(pthread_self());

  // 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
  // when malloc takes a lock). This will deadlock the thread, so only try to
  // take the lock if the current thread is not using the queue. We then hope
  // the queue is executed later when it is unlocked.
  bool 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);
  em_task_queue* tasks = get_tasks_for_thread(q, pthread_self());
  pthread_mutex_unlock(&q->mutex);

  if (tasks != NULL && !tasks->processing) {
    // Found the task queue and it is not already being processed; process it.
    em_task_queue_execute(tasks);
  }

  if (is_system_queue) {
    system_queue_in_use = false;
  }
}

static bool do_proxy(em_proxying_queue* q, pthread_t target_thread, task t) {
  assert(q != NULL);