qemu-coroutine.c

   1 /*
   2  * QEMU coroutines
   3  *
   4  * Copyright IBM, Corp. 2011
   5  *
   6  * Authors:
   7  *  Stefan Hajnoczi    <stefanha@linux.vnet.ibm.com>
   8  *  Kevin Wolf         <kwolf@redhat.com>
   9  *
  10  * This work is licensed under the terms of the GNU LGPL, version 2 or later.
  11  * See the COPYING.LIB file in the top-level directory.
  12  *
  13  */
  14
  15 #include "trace.h"
  16 #include "qemu-common.h"
  17 #include "qemu/thread.h"
  18 #include "qemu/atomic.h"
  19 #include "block/coroutine.h"
  20 #include "block/coroutine_int.h"
  21
  22 enum {
  23     POOL_BATCH_SIZE = 64,
  24 };
  25
  26 /** Free list to speed up creation */
  27 static QSLIST_HEAD(, Coroutine) release_pool = QSLIST_HEAD_INITIALIZER(pool);
  28 static unsigned int release_pool_size;
  29 static __thread QSLIST_HEAD(, Coroutine) alloc_pool = QSLIST_HEAD_INITIALIZER(pool);
  30 static __thread unsigned int alloc_pool_size;
  31 static __thread Notifier coroutine_pool_cleanup_notifier;
  32
  33 static void coroutine_pool_cleanup(Notifier *n, void *value)
  34 {
  35     Coroutine *co;
  36     Coroutine *tmp;
  37
  38     QSLIST_FOREACH_SAFE(co, &alloc_pool, pool_next, tmp) {
  39         QSLIST_REMOVE_HEAD(&alloc_pool, pool_next);
  40         qemu_coroutine_delete(co);
  41     }
  42 }
  43
  44 Coroutine *qemu_coroutine_create(CoroutineEntry *entry)
  45 {
  46     Coroutine *co = NULL;
  47
  48     if (CONFIG_COROUTINE_POOL) {
  49         co = QSLIST_FIRST(&alloc_pool);
  50         if (!co) {
  51             if (release_pool_size > POOL_BATCH_SIZE) {
  52                 /* Slow path; a good place to register the destructor, too.  */
  53                 if (!coroutine_pool_cleanup_notifier.notify) {
  54                     coroutine_pool_cleanup_notifier.notify = coroutine_pool_cleanup;
  55                     qemu_thread_atexit_add(&coroutine_pool_cleanup_notifier);
  56                 }
  57
  58                 /* This is not exact; there could be a little skew between
  59                  * release_pool_size and the actual size of release_pool.  But
  60                  * it is just a heuristic, it does not need to be perfect.
  61                  */
  62                 alloc_pool_size = atomic_xchg(&release_pool_size, 0);
  63                 QSLIST_MOVE_ATOMIC(&alloc_pool, &release_pool);
  64                 co = QSLIST_FIRST(&alloc_pool);
  65             }
  66         }
  67         if (co) {
  68             QSLIST_REMOVE_HEAD(&alloc_pool, pool_next);
  69             alloc_pool_size--;
  70         }
  71     }
  72
  73     if (!co) {
  74         co = qemu_coroutine_new();
  75     }
  76
  77     co->entry = entry;
  78     QTAILQ_INIT(&co->co_queue_wakeup);
  79     return co;
  80 }
  81
  82 static void coroutine_delete(Coroutine *co)
  83 {
  84     co->caller = NULL;
  85
  86     if (CONFIG_COROUTINE_POOL) {
  87         if (release_pool_size < POOL_BATCH_SIZE * 2) {
  88             QSLIST_INSERT_HEAD_ATOMIC(&release_pool, co, pool_next);
  89             atomic_inc(&release_pool_size);
  90             return;
  91         }
  92         if (alloc_pool_size < POOL_BATCH_SIZE) {
  93             QSLIST_INSERT_HEAD(&alloc_pool, co, pool_next);
  94             alloc_pool_size++;
  95             return;
  96         }
  97     }
  98
  99     qemu_coroutine_delete(co);
 100 }
 101
 102 static void coroutine_swap(Coroutine *from, Coroutine *to)
 103 {
 104     CoroutineAction ret;
 105
 106     ret = qemu_coroutine_switch(from, to, COROUTINE_YIELD);
 107
 108     qemu_co_queue_run_restart(to);
 109
 110     switch (ret) {
 111     case COROUTINE_YIELD:
 112         return;
 113     case COROUTINE_TERMINATE:
 114         trace_qemu_coroutine_terminate(to);
 115         coroutine_delete(to);
 116         return;
 117     default:
 118         abort();
 119     }
 120 }
 121
 122 void qemu_coroutine_enter(Coroutine *co, void *opaque)
 123 {
 124     Coroutine *self = qemu_coroutine_self();
 125
 126     trace_qemu_coroutine_enter(self, co, opaque);
 127
 128     if (co->caller) {
 129         fprintf(stderr, "Co-routine re-entered recursively\n");
 130         abort();
 131     }
 132
 133     co->caller = self;
 134     co->entry_arg = opaque;
 135     coroutine_swap(self, co);
 136 }
 137
 138 void coroutine_fn qemu_coroutine_yield(void)
 139 {
 140     Coroutine *self = qemu_coroutine_self();
 141     Coroutine *to = self->caller;
 142
 143     trace_qemu_coroutine_yield(self, to);
 144
 145     if (!to) {
 146         fprintf(stderr, "Co-routine is yielding to no one\n");
 147         abort();
 148     }
 149
 150     self->caller = NULL;
 151     coroutine_swap(self, to);
 152 }