tests: ACPI: update pc/SSDT.bridge due to new alg of PCI tree creation

[qemu.git] / tests / test-coroutine.c

diff --git a/tests/test-coroutine.c b/tests/test-coroutine.c
index 4c6cc81fb98da864f9c101735cd0fb2709ba20bf..27d1b6f8e851f8ee8860e4c3d7d46049f2b75c94 100644 (file)
--- a/tests/test-coroutine.c
+++ b/tests/test-coroutine.c
@@ -150,6 +150,59 @@ static void test_lifecycle(void)
     g_assert(done); /* expect done to be true (second time) */
 }
 
+
+#define RECORD_SIZE 10 /* Leave some room for expansion */
+struct coroutine_position {
+    int func;
+    int state;
+};
+static struct coroutine_position records[RECORD_SIZE];
+static unsigned record_pos;
+
+static void record_push(int func, int state)
+{
+    struct coroutine_position *cp = &records[record_pos++];
+    g_assert_cmpint(record_pos, <, RECORD_SIZE);
+    cp->func = func;
+    cp->state = state;
+}
+
+static void coroutine_fn co_order_test(void *opaque)
+{
+    record_push(2, 1);
+    g_assert(qemu_in_coroutine());
+    qemu_coroutine_yield();
+    record_push(2, 2);
+    g_assert(qemu_in_coroutine());
+}
+
+static void do_order_test(void)
+{
+    Coroutine *co;
+
+    co = qemu_coroutine_create(co_order_test);
+    record_push(1, 1);
+    qemu_coroutine_enter(co, NULL);
+    record_push(1, 2);
+    g_assert(!qemu_in_coroutine());
+    qemu_coroutine_enter(co, NULL);
+    record_push(1, 3);
+    g_assert(!qemu_in_coroutine());
+}
+
+static void test_order(void)
+{
+    int i;
+    const struct coroutine_position expected_pos[] = {
+        {1, 1,}, {2, 1}, {1, 2}, {2, 2}, {1, 3}
+    };
+    do_order_test();
+    g_assert_cmpint(record_pos, ==, 5);
+    for (i = 0; i < record_pos; i++) {
+        g_assert_cmpint(records[i].func , ==, expected_pos[i].func );
+        g_assert_cmpint(records[i].state, ==, expected_pos[i].state);
+    }
+}
 /*
  * Lifecycle benchmark
  */
@@ -182,17 +235,17 @@ static void perf_nesting(void)
     unsigned int i, maxcycles, maxnesting;
     double duration;
 
-    maxcycles = 100000000;
-    maxnesting = 20000;
+    maxcycles = 10000;
+    maxnesting = 1000;
     Coroutine *root;
-    NestData nd = {
-        .n_enter  = 0,
-        .n_return = 0,
-        .max      = maxnesting,
-    };
 
     g_test_timer_start();
     for (i = 0; i < maxcycles; i++) {
+        NestData nd = {
+            .n_enter  = 0,
+            .n_return = 0,
+            .max      = maxnesting,
+        };
         root = qemu_coroutine_create(nest);
         qemu_coroutine_enter(root, &nd);
     }
@@ -202,6 +255,90 @@ static void perf_nesting(void)
         maxcycles, maxnesting, duration);
 }
 
+/*
+ * Yield benchmark
+ */
+
+static void coroutine_fn yield_loop(void *opaque)
+{
+    unsigned int *counter = opaque;
+
+    while ((*counter) > 0) {
+        (*counter)--;
+        qemu_coroutine_yield();
+    }
+}
+
+static void perf_yield(void)
+{
+    unsigned int i, maxcycles;
+    double duration;
+
+    maxcycles = 100000000;
+    i = maxcycles;
+    Coroutine *coroutine = qemu_coroutine_create(yield_loop);
+
+    g_test_timer_start();
+    while (i > 0) {
+        qemu_coroutine_enter(coroutine, &i);
+    }
+    duration = g_test_timer_elapsed();
+
+    g_test_message("Yield %u iterations: %f s\n",
+        maxcycles, duration);
+}
+
+static __attribute__((noinline)) void dummy(unsigned *i)
+{
+    (*i)--;
+}
+
+static void perf_baseline(void)
+{
+    unsigned int i, maxcycles;
+    double duration;
+
+    maxcycles = 100000000;
+    i = maxcycles;
+
+    g_test_timer_start();
+    while (i > 0) {
+        dummy(&i);
+    }
+    duration = g_test_timer_elapsed();
+
+    g_test_message("Function call %u iterations: %f s\n",
+        maxcycles, duration);
+}
+
+static __attribute__((noinline)) void perf_cost_func(void *opaque)
+{
+    qemu_coroutine_yield();
+}
+
+static void perf_cost(void)
+{
+    const unsigned long maxcycles = 40000000;
+    unsigned long i = 0;
+    double duration;
+    unsigned long ops;
+    Coroutine *co;
+
+    g_test_timer_start();
+    while (i++ < maxcycles) {
+        co = qemu_coroutine_create(perf_cost_func);
+        qemu_coroutine_enter(co, &i);
+        qemu_coroutine_enter(co, NULL);
+    }
+    duration = g_test_timer_elapsed();
+    ops = (long)(maxcycles / (duration * 1000));
+
+    g_test_message("Run operation %lu iterations %f s, %luK operations/s, "
+                   "%luns per coroutine",
+                   maxcycles,
+                   duration, ops,
+                   (unsigned long)(1000000000.0 * duration / maxcycles));
+}
 
 int main(int argc, char **argv)
 {
@@ -211,9 +348,13 @@ int main(int argc, char **argv)
     g_test_add_func("/basic/nesting", test_nesting);
     g_test_add_func("/basic/self", test_self);
     g_test_add_func("/basic/in_coroutine", test_in_coroutine);
+    g_test_add_func("/basic/order", test_order);
     if (g_test_perf()) {
         g_test_add_func("/perf/lifecycle", perf_lifecycle);
         g_test_add_func("/perf/nesting", perf_nesting);
+        g_test_add_func("/perf/yield", perf_yield);
+        g_test_add_func("/perf/function-call", perf_baseline);
+        g_test_add_func("/perf/cost", perf_cost);
     }
     return g_test_run();
 }