[Qemu-devel] [PATCH v1] test-coroutine: test cost introduced by coroutine

[Qemu-devel] [PATCH v1] test-coroutine: test cost introduced by coroutine

[Ming Lei]

This test runs dummy function with coroutine by using
two enter and one yield since which is a common usage.

So we can see the cost introduced by corouting for running
one function, for example:

	Run operation 20000000 iterations 4.841071 s, 4131K operations/s
	242ns per coroutine

Signed-off-by: Ming Lei <ming.lei@canonical.com>
---
 tests/test-coroutine.c |   30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/tests/test-coroutine.c b/tests/test-coroutine.c
index 6e634f4..e22fae1 100644
--- a/tests/test-coroutine.c
+++ b/tests/test-coroutine.c
@@ -311,6 +311,35 @@ static void perf_baseline(void)
         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 * duration) / maxcycles);
+}
+
 int main(int argc, char **argv)
 {
     g_test_init(&argc, &argv, NULL);
@@ -325,6 +354,7 @@ int main(int argc, char **argv)
         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();
 }
-- 
1.7.9.5

Re: [Qemu-devel] [PATCH v1] test-coroutine: test cost introduced by coroutine

[Benoît Canet]

The Wednesday 13 Aug 2014 à 18:08:47 (+0800), Ming Lei wrote :
> This test runs dummy function with coroutine by using
> two enter and one yield since which is a common usage.
> 
> So we can see the cost introduced by corouting for running
> one function, for example:
> 
> 	Run operation 20000000 iterations 4.841071 s, 4131K operations/s
> 	242ns per coroutine
> 
> Signed-off-by: Ming Lei <ming.lei@canonical.com>
> ---
>  tests/test-coroutine.c |   30 ++++++++++++++++++++++++++++++
>  1 file changed, 30 insertions(+)
> 
> diff --git a/tests/test-coroutine.c b/tests/test-coroutine.c
> index 6e634f4..e22fae1 100644
> --- a/tests/test-coroutine.c
> +++ b/tests/test-coroutine.c
> @@ -311,6 +311,35 @@ static void perf_baseline(void)
>          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);

I am not sure qemu_coroutine_create is systematically used.
I rather believe the code try to reuse existing coroutine.

> +        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 * duration) / maxcycles);
> +}
> +
>  int main(int argc, char **argv)
>  {
>      g_test_init(&argc, &argv, NULL);
> @@ -325,6 +354,7 @@ int main(int argc, char **argv)
>          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();
>  }
> -- 
> 1.7.9.5
> 
> 

Re: [Qemu-devel] [PATCH v1] test-coroutine: test cost introduced by coroutine

[Gabriel Kerneis]

On 13 août 2014 16:27:29 CEST, "Benoît Canet" <benoit.canet@irqsave.net> wrote:
> The Wednesday 13 Aug 2014 à 18:08:47 (+0800), Ming Lei wrote :
> > This test runs dummy function with coroutine by using
> > two enter and one yield since which is a common usage.
> > 
> > So we can see the cost introduced by corouting for running
> > one function, for example:
> > 
> > 	Run operation 20000000 iterations 4.841071 s, 4131K operations/s
> > 	242ns per coroutine
> > 
> > Signed-off-by: Ming Lei <ming.lei@canonical.com>
> > ---
> >  tests/test-coroutine.c |   30 ++++++++++++++++++++++++++++++
> >  1 file changed, 30 insertions(+)
> > 
> > diff --git a/tests/test-coroutine.c b/tests/test-coroutine.c
> > index 6e634f4..e22fae1 100644
> > --- a/tests/test-coroutine.c
> > +++ b/tests/test-coroutine.c
> > @@ -311,6 +311,35 @@ static void perf_baseline(void)
> >          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);
> 
> I am not sure qemu_coroutine_create is systematically used.
> I rather believe the code try to reuse existing coroutine.

Isn't it what the coroutine pool is for? Is there really code duplicating it manually? 


> 
> > +        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 * duration) /
> maxcycles);
> > +}
> > +
> >  int main(int argc, char **argv)
> >  {
> >      g_test_init(&argc, &argv, NULL);
> > @@ -325,6 +354,7 @@ int main(int argc, char **argv)
> >          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();
> >  }
> > -- 
> > 1.7.9.5
> > 
> > 

-- 
Gabriel

Re: [Qemu-devel] [PATCH v1] test-coroutine: test cost introduced by coroutine

[Ming Lei]

On Wed, Aug 13, 2014 at 10:27 PM, Benoît Canet <benoit.canet@irqsave.net> wrote:
> The Wednesday 13 Aug 2014 à 18:08:47 (+0800), Ming Lei wrote :
>> This test runs dummy function with coroutine by using
>> two enter and one yield since which is a common usage.
>>
>> So we can see the cost introduced by corouting for running
>> one function, for example:
>>
>>       Run operation 20000000 iterations 4.841071 s, 4131K operations/s
>>       242ns per coroutine
>>
>> Signed-off-by: Ming Lei <ming.lei@canonical.com>
>> ---
>>  tests/test-coroutine.c |   30 ++++++++++++++++++++++++++++++
>>  1 file changed, 30 insertions(+)
>>
>> diff --git a/tests/test-coroutine.c b/tests/test-coroutine.c
>> index 6e634f4..e22fae1 100644
>> --- a/tests/test-coroutine.c
>> +++ b/tests/test-coroutine.c
>> @@ -311,6 +311,35 @@ static void perf_baseline(void)
>>          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);
>
> I am not sure qemu_coroutine_create is systematically used.
> I rather believe the code try to reuse existing coroutine.

In block layer, it is a common usage, please see bdrv_co_aio_rw_vector(),
and most of times the allocation hits on the pool, as mentioned by
Gabriel Kerneis().  In this test, it should always be from the pool.

Ming


>
>> +        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 * duration) / maxcycles);
>> +}
>> +
>>  int main(int argc, char **argv)
>>  {
>>      g_test_init(&argc, &argv, NULL);
>> @@ -325,6 +354,7 @@ int main(int argc, char **argv)
>>          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();
>>  }
>> --
>> 1.7.9.5
>>
>>

Re: [Qemu-devel] [PATCH v1] test-coroutine: test cost introduced by coroutine

[Ming Lei]

Hi Guys,

On Wed, Aug 13, 2014 at 6:08 PM, Ming Lei <ming.lei@canonical.com> wrote:
> This test runs dummy function with coroutine by using
> two enter and one yield since which is a common usage.
>
> So we can see the cost introduced by corouting for running
> one function, for example:
>
>         Run operation 20000000 iterations 4.841071 s, 4131K operations/s
>         242ns per coroutine
>
> Signed-off-by: Ming Lei <ming.lei@canonical.com>

Ping...

Thanks,

Re: [Qemu-devel] [PATCH v1] test-coroutine: test cost introduced by coroutine

[Kevin Wolf]

Am 13.08.2014 um 12:08 hat Ming Lei geschrieben:
> This test runs dummy function with coroutine by using
> two enter and one yield since which is a common usage.
> 
> So we can see the cost introduced by corouting for running
> one function, for example:
> 
> 	Run operation 20000000 iterations 4.841071 s, 4131K operations/s
> 	242ns per coroutine
> 
> Signed-off-by: Ming Lei <ming.lei@canonical.com>

Thanks, applied to the block branch.

Kevin