/thread-pool.c - Diff - qemu - Greek Research and Technology Network's projects

Revision f7311ccc thread-pool.c

     #include "qemu/event_notifier.h"
     #include "block/thread-pool.h"
     typedef struct ThreadPool ThreadPool;
     static void do_spawn_thread(ThreadPool *pool);
     typedef struct ThreadPoolElement ThreadPoolElement;
-...
     struct ThreadPool {
         EventNotifier notifier;
         AioContext *ctx;
         QemuMutex lock;
         QemuCond check_cancel;
         QemuCond worker_stopped;
         QemuSemaphore sem;
         int max_threads;
         QEMUBH *new_thread_bh;
-...
         int new_threads;     /* backlog of threads we need to create */
         int pending_threads; /* threads created but not running yet */
         int pending_cancellations; /* whether we need a cond_broadcast */
         bool stopping;
     };
     /* Currently there is only one thread pool instance. */
-...
         pool->pending_threads--;
         do_spawn_thread(pool);
         while (1) {
         while (!pool->stopping) {
             ThreadPoolElement *req;
             int ret;
-...
                 qemu_mutex_lock(&pool->lock);
                 pool->idle_threads--;
             } while (ret == -1 && !QTAILQ_EMPTY(&pool->request_list));
             if (ret == -1) {
             if (ret == -1 || pool->stopping) {
                 break;
+            }
-...
+        }
         pool->cur_threads--;
         qemu_cond_signal(&pool->worker_stopped);
         qemu_mutex_unlock(&pool->lock);
         return NULL;
+    }
-...
         memset(pool, 0, sizeof(*pool));
         event_notifier_init(&pool->notifier, false);
         pool->ctx = ctx;
         qemu_mutex_init(&pool->lock);
         qemu_cond_init(&pool->check_cancel);
         qemu_cond_init(&pool->worker_stopped);
         qemu_sem_init(&pool->sem, 0);
         pool->max_threads = 64;
         pool->new_thread_bh = aio_bh_new(ctx, spawn_thread_bh_fn, pool);
-...
                                thread_pool_active);
+    }
     ThreadPool *thread_pool_new(AioContext *ctx)
+    {
         ThreadPool *pool = g_new(ThreadPool, 1);
         thread_pool_init_one(pool, ctx);
         return pool;
+    }
     void thread_pool_free(ThreadPool *pool)
+    {
         if (!pool) {
             return;
+        }
         assert(QLIST_EMPTY(&pool->head));
         qemu_mutex_lock(&pool->lock);
         /* Stop new threads from spawning */
         qemu_bh_delete(pool->new_thread_bh);
         pool->cur_threads -= pool->new_threads;
         pool->new_threads = 0;
         /* Wait for worker threads to terminate */
         pool->stopping = true;
         while (pool->cur_threads > 0) {
             qemu_sem_post(&pool->sem);
             qemu_cond_wait(&pool->worker_stopped, &pool->lock);
+        }
         qemu_mutex_unlock(&pool->lock);
         aio_set_event_notifier(pool->ctx, &pool->notifier, NULL, NULL);
         qemu_sem_destroy(&pool->sem);
         qemu_cond_destroy(&pool->check_cancel);
         qemu_cond_destroy(&pool->worker_stopped);
         qemu_mutex_destroy(&pool->lock);
         event_notifier_cleanup(&pool->notifier);
         g_free(pool);
+    }
     static void thread_pool_init(void)
+    {
         thread_pool_init_one(&global_pool, NULL);

Also available in: Unified diff

Archipelago » qemu

Revision f7311ccc thread-pool.c