/ - Diff - qemu - Greek Research and Technology Network's projects

             BlockDriverCompletionFunc *cb, void *opaque, int type)
+    {
         RawPosixAIOData *acb = g_slice_new(RawPosixAIOData);
         ThreadPool *pool;
         acb->bs = bs;
         acb->aio_type = type;
-...
         acb->aio_offset = sector_num * 512;
         trace_paio_submit(acb, opaque, sector_num, nb_sectors, type);
         return thread_pool_submit_aio(aio_worker, acb, cb, opaque);
         pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
         return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
+    }
     static BlockDriverAIOCB *raw_aio_submit(BlockDriverState *bs,
-...
+    {
         BDRVRawState *s = bs->opaque;
         RawPosixAIOData *acb;
         ThreadPool *pool;
         if (fd_open(bs) < 0)
             return NULL;
-...
         acb->aio_offset = 0;
         acb->aio_ioctl_buf = buf;
         acb->aio_ioctl_cmd = req;
         return thread_pool_submit_aio(aio_worker, acb, cb, opaque);
         pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
         return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
+    }
     #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

             BlockDriverCompletionFunc *cb, void *opaque, int type)
+    {
         RawWin32AIOData *acb = g_slice_new(RawWin32AIOData);
         ThreadPool *pool;
         acb->bs = bs;
         acb->hfile = hfile;
-...
         acb->aio_offset = sector_num * 512;
         trace_paio_submit(acb, opaque, sector_num, nb_sectors, type);
         return thread_pool_submit_aio(aio_worker, acb, cb, opaque);
         pool = aio_get_thread_pool(bdrv_get_aio_context(bs));
         return thread_pool_submit_aio(pool, aio_worker, acb, cb, opaque);
+    }
     int qemu_ftruncate64(int fd, int64_t length)

     ThreadPool *thread_pool_new(struct AioContext *ctx);
     void thread_pool_free(ThreadPool *pool);
     BlockDriverAIOCB *thread_pool_submit_aio(ThreadPoolFunc *func, void *arg,
          BlockDriverCompletionFunc *cb, void *opaque);
     int coroutine_fn thread_pool_submit_co(ThreadPoolFunc *func, void *arg);
     void thread_pool_submit(ThreadPoolFunc *func, void *arg);
     BlockDriverAIOCB *thread_pool_submit_aio(ThreadPool *pool,
             ThreadPoolFunc *func, void *arg,
             BlockDriverCompletionFunc *cb, void *opaque);
     int coroutine_fn thread_pool_submit_co(ThreadPool *pool,
             ThreadPoolFunc *func, void *arg);
     void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg);
     #endif

     #include "block/thread-pool.h"
     #include "block/block.h"
     static AioContext *ctx;
     static ThreadPool *pool;
     static int active;
     typedef struct {
-...
         active--;
+    }
     /* A non-blocking poll of the main AIO context (we cannot use aio_poll
      * because we do not know the AioContext).
      */
     static void qemu_aio_wait_nonblocking(void)
+    {
         qemu_notify_event();
         qemu_aio_wait();
+    }
     /* Wait until all aio and bh activity has finished */
     static void qemu_aio_wait_all(void)
+    {
         while (qemu_aio_wait()) {
         while (aio_poll(ctx, true)) {
             /* Do nothing */
+        }
+    }
-...
     static void test_submit(void)
+    {
         WorkerTestData data = { .n = 0 };
         thread_pool_submit(worker_cb, &data);
         thread_pool_submit(pool, worker_cb, &data);
         qemu_aio_wait_all();
         g_assert_cmpint(data.n, ==, 1);
+    }
-...
     static void test_submit_aio(void)
+    {
         WorkerTestData data = { .n = 0, .ret = -EINPROGRESS };
         data.aiocb = thread_pool_submit_aio(worker_cb, &data, done_cb, &data);
         data.aiocb = thread_pool_submit_aio(pool, worker_cb, &data,
                                             done_cb, &data);
         /* The callbacks are not called until after the first wait.  */
         active = 1;
-...
         active = 1;
         data->n = 0;
         data->ret = -EINPROGRESS;
         thread_pool_submit_co(worker_cb, data);
         thread_pool_submit_co(pool, worker_cb, data);
         /* The test continues in test_submit_co, after qemu_coroutine_enter... */
-...
         for (i = 0; i < 100; i++) {
             data[i].n = 0;
             data[i].ret = -EINPROGRESS;
             thread_pool_submit_aio(worker_cb, &data[i], done_cb, &data[i]);
             thread_pool_submit_aio(pool, worker_cb, &data[i], done_cb, &data[i]);
+        }
         active = 100;
         while (active > 0) {
             qemu_aio_wait();
             aio_poll(ctx, true);
+        }
         for (i = 0; i < 100; i++) {
             g_assert_cmpint(data[i].n, ==, 1);
-...
         for (i = 0; i < 100; i++) {
             data[i].n = 0;
             data[i].ret = -EINPROGRESS;
             data[i].aiocb = thread_pool_submit_aio(long_cb, &data[i],
             data[i].aiocb = thread_pool_submit_aio(pool, long_cb, &data[i],
                                                    done_cb, &data[i]);
+        }
-...
          * run, but do not waste too much time...
          */
         active = 100;
         qemu_aio_wait_nonblocking();
         aio_notify(ctx);
         aio_poll(ctx, false);
         /* Wait some time for the threads to start, with some sanity
          * testing on the behavior of the scheduler...
-...
     int main(int argc, char **argv)
+    {
         /* These should be removed once each AioContext has its thread pool.
          * The test should create its own AioContext.
          */
         qemu_init_main_loop();
         bdrv_init();
         int ret;
         ctx = aio_context_new();
         pool = aio_get_thread_pool(ctx);
         g_test_init(&argc, &argv, NULL);
         g_test_add_func("/thread-pool/submit", test_submit);
-...
         g_test_add_func("/thread-pool/submit-co", test_submit_co);
         g_test_add_func("/thread-pool/submit-many", test_submit_many);
         g_test_add_func("/thread-pool/cancel", test_cancel);
         return g_test_run();
         ret = g_test_run();
         aio_context_unref(ctx);
         return ret;
+    }

         bool stopping;
     };
     /* Currently there is only one thread pool instance. */
     static ThreadPool global_pool;
     static void *worker_thread(void *opaque)
+    {
         ThreadPool *pool = opaque;
-...
         .cancel             = thread_pool_cancel,
     };
     BlockDriverAIOCB *thread_pool_submit_aio(ThreadPoolFunc *func, void *arg,
     BlockDriverAIOCB *thread_pool_submit_aio(ThreadPool *pool,
             ThreadPoolFunc *func, void *arg,
             BlockDriverCompletionFunc *cb, void *opaque)
+    {
         ThreadPool *pool = &global_pool;
         ThreadPoolElement *req;
         req = qemu_aio_get(&thread_pool_aiocb_info, NULL, cb, opaque);
-...
         qemu_coroutine_enter(co->co, NULL);
+    }
     int coroutine_fn thread_pool_submit_co(ThreadPoolFunc *func, void *arg)
     int coroutine_fn thread_pool_submit_co(ThreadPool *pool, ThreadPoolFunc *func,
                                            void *arg)
+    {
         ThreadPoolCo tpc = { .co = qemu_coroutine_self(), .ret = -EINPROGRESS };
         assert(qemu_in_coroutine());
         thread_pool_submit_aio(func, arg, thread_pool_co_cb, &tpc);
         thread_pool_submit_aio(pool, func, arg, thread_pool_co_cb, &tpc);
         qemu_coroutine_yield();
         return tpc.ret;
+    }
     void thread_pool_submit(ThreadPoolFunc *func, void *arg)
     void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg)
+    {
         thread_pool_submit_aio(func, arg, NULL, NULL);
         thread_pool_submit_aio(pool, func, arg, NULL, NULL);
+    }
     static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
-...
         event_notifier_cleanup(&pool->notifier);
         g_free(pool);
+    }
     static void thread_pool_init(void)
+    {
         thread_pool_init_one(&global_pool, NULL);
+    }
     block_init(thread_pool_init)

Archipelago » qemu

Revision c4d9d196