From patchwork Tue Jun 28 09:01:28 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peter Lieven X-Patchwork-Id: 9202329 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 4CB656075F for ; Tue, 28 Jun 2016 09:11:26 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 3A36B285FF for ; Tue, 28 Jun 2016 09:11:26 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 2EC3B28601; Tue, 28 Jun 2016 09:11:26 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.9 required=2.0 tests=BAYES_00,RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 8432A285FF for ; Tue, 28 Jun 2016 09:11:25 +0000 (UTC) Received: from localhost ([::1]:35214 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bHp3E-00018m-Ix for patchwork-qemu-devel@patchwork.kernel.org; Tue, 28 Jun 2016 05:11:24 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:34870) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bHouT-000733-Jc for qemu-devel@nongnu.org; Tue, 28 Jun 2016 05:02:23 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1bHouS-0003Qf-0Z for qemu-devel@nongnu.org; Tue, 28 Jun 2016 05:02:21 -0400 Received: from mx-v6.kamp.de ([2a02:248:0:51::16]:56627 helo=mx01.kamp.de) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bHouR-0003Pq-Ml for qemu-devel@nongnu.org; Tue, 28 Jun 2016 05:02:19 -0400 Received: (qmail 27454 invoked by uid 89); 28 Jun 2016 09:02:18 -0000 Received: from [195.62.97.28] by client-16-kamp (envelope-from , uid 89) with qmail-scanner-2010/03/19-MF (clamdscan: 0.99.2/21804. hbedv: 8.3.40.44/7.12.99.34. avast: 1.2.2/16062800. spamassassin: 3.4.1. Clear:RC:1(195.62.97.28):. Processed in 0.226304 secs); 28 Jun 2016 09:02:18 -0000 Received: from smtp.kamp.de (HELO submission.kamp.de) ([195.62.97.28]) by mx01.kamp.de with ESMTPS (DHE-RSA-AES256-GCM-SHA384 encrypted); 28 Jun 2016 09:02:15 -0000 X-GL_Whitelist: yes Received: (qmail 29643 invoked from network); 28 Jun 2016 09:01:47 -0000 Received: from lieven-pc.kamp-intra.net (HELO lieven-pc) (relay@kamp.de@::ffff:172.21.12.60) by submission.kamp.de with ESMTPS (DHE-RSA-AES256-GCM-SHA384 encrypted) ESMTPA; 28 Jun 2016 09:01:47 -0000 Received: by lieven-pc (Postfix, from userid 1000) id 499D32084F; Tue, 28 Jun 2016 11:01:46 +0200 (CEST) From: Peter Lieven To: qemu-devel@nongnu.org Date: Tue, 28 Jun 2016 11:01:28 +0200 Message-Id: <1467104499-27517-5-git-send-email-pl@kamp.de> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1467104499-27517-1-git-send-email-pl@kamp.de> References: <1467104499-27517-1-git-send-email-pl@kamp.de> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 2a02:248:0:51::16 Subject: [Qemu-devel] [PATCH 04/15] coroutine: add a knob to disable the shared release pool X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, peter.maydell@linaro.org, mst@redhat.com, Peter Lieven , dgilbert@redhat.com, mreitz@redhat.com, kraxel@redhat.com, pbonzini@redhat.com Errors-To: qemu-devel-bounces+patchwork-qemu-devel=patchwork.kernel.org@nongnu.org Sender: "Qemu-devel" X-Virus-Scanned: ClamAV using ClamSMTP the current coroutine freelist implementation has 2 kinds of pools. One shared release pool between all threads and additionally one allocation pool per thread. The release pool is especially necessary if the coroutine is created in a different thread than it is released. This is e.g. the case if an IDE interface is used. But in times of virtio and dataplane the the release pool adds costs which are not entirely necessary. At first if virtio is used the release pool tends to fill up to 100% because all coroutines are first handed back to the release pool. On coroutine create a thread can steal this release pool and make it its local allocation pool, but during mixed I/O pattern at the end the release pool is full of useless coroutines and the alloc_pool has also filled to maximum size. So this patch introduces a knob to disable the release pool to avoid this behaviour. If this switch is used it should be made sure that all fast block devices use virtio and each virtio device has its own thread (dataplane). An IDE cdrom might still be used, but coroutine creation will be slow, but a CDROM is considred slow anyway. Signed-off-by: Peter Lieven --- configure | 15 ++++++++-- util/qemu-coroutine.c | 79 ++++++++++++++++++++++++++++----------------------- 2 files changed, 56 insertions(+), 38 deletions(-) diff --git a/configure b/configure index 82bcc25..fb29034 100755 --- a/configure +++ b/configure @@ -296,6 +296,7 @@ libiscsi="" libnfs="" coroutine="" coroutine_pool="" +coroutine_release_pool="yes" coroutine_stack_size_debug="no" seccomp="" glusterfs="" @@ -1001,10 +1002,14 @@ for opt do ;; --with-coroutine=*) coroutine="$optarg" ;; - --disable-coroutine-pool) coroutine_pool="no" + --disable-coroutine-pool) + coroutine_pool="no" + coroutine_release_pool="no" ;; --enable-coroutine-pool) coroutine_pool="yes" ;; + --disable-coroutine-release-pool) coroutine_release_pool="no" + ;; --enable-coroutine-stack-size-debug) coroutine_stack_size_debug="yes" ;; --disable-docs) docs="no" @@ -1364,6 +1369,7 @@ disabled with --disable-FEATURE, default is enabled if available: (for reading bzip2-compressed dmg images) seccomp seccomp support coroutine-pool coroutine freelist (better performance) + coroutine-release-pool coroutine freelist is shared between threads coroutine-stack-size-debug report coroutine max stack usage (only for debugging) glusterfs GlusterFS backend @@ -4310,6 +4316,7 @@ if test "$coroutine_stack_size_debug" = "yes"; then if test "$coroutine_pool" = "yes"; then echo "WARN: disabling coroutine pool for stack size debugging" coroutine_pool=no + coroutine_release_pool=no fi fi @@ -4880,6 +4887,7 @@ echo "QGA MSI support $guest_agent_msi" echo "seccomp support $seccomp" echo "coroutine backend $coroutine" echo "coroutine pool $coroutine_pool" +echo "coroutine release pool $coroutine_release_pool" echo "coroutine stack size debug $coroutine_stack_size_debug" echo "GlusterFS support $glusterfs" echo "Archipelago support $archipelago" @@ -5347,12 +5355,13 @@ fi echo "CONFIG_COROUTINE_BACKEND=$coroutine" >> $config_host_mak if test "$coroutine_pool" = "yes" ; then echo "CONFIG_COROUTINE_POOL=1" >> $config_host_mak -else - echo "CONFIG_COROUTINE_POOL=0" >> $config_host_mak fi if test "$coroutine_stack_size_debug" = "yes" ; then echo "CONFIG_COROUTINE_STACK_SIZE_DEBUG=y" >> $config_host_mak fi +if test "$coroutine_release_pool" = "yes"; then + echo "CONFIG_COROUTINE_RELEASE_POOL=y" >> $config_host_mak +fi if test "$open_by_handle_at" = "yes" ; then echo "CONFIG_OPEN_BY_HANDLE=y" >> $config_host_mak diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c index 5816702..7dda0ca 100644 --- a/util/qemu-coroutine.c +++ b/util/qemu-coroutine.c @@ -20,13 +20,12 @@ #include "qemu/coroutine.h" #include "qemu/coroutine_int.h" +#ifdef CONFIG_COROUTINE_POOL +/* per thread free list to speed up creation */ enum { POOL_BATCH_SIZE = 64, }; -/** Free list to speed up creation */ -static QSLIST_HEAD(, Coroutine) release_pool = QSLIST_HEAD_INITIALIZER(pool); -static unsigned int release_pool_size; static __thread QSLIST_HEAD(, Coroutine) alloc_pool = QSLIST_HEAD_INITIALIZER(pool); static __thread unsigned int alloc_pool_size; static __thread Notifier coroutine_pool_cleanup_notifier; @@ -41,35 +40,43 @@ static void coroutine_pool_cleanup(Notifier *n, void *value) qemu_coroutine_delete(co); } } +#endif +#ifdef CONFIG_COROUTINE_RELEASE_POOL +/* add an additional shared release pool */ +static QSLIST_HEAD(, Coroutine) release_pool = QSLIST_HEAD_INITIALIZER(pool); +static unsigned int release_pool_size; +#endif Coroutine *qemu_coroutine_create(CoroutineEntry *entry) { Coroutine *co = NULL; - if (CONFIG_COROUTINE_POOL) { - co = QSLIST_FIRST(&alloc_pool); - if (!co) { - if (release_pool_size > POOL_BATCH_SIZE) { - /* Slow path; a good place to register the destructor, too. */ - if (!coroutine_pool_cleanup_notifier.notify) { - coroutine_pool_cleanup_notifier.notify = coroutine_pool_cleanup; - qemu_thread_atexit_add(&coroutine_pool_cleanup_notifier); - } - - /* This is not exact; there could be a little skew between - * release_pool_size and the actual size of release_pool. But - * it is just a heuristic, it does not need to be perfect. - */ - alloc_pool_size = atomic_xchg(&release_pool_size, 0); - QSLIST_MOVE_ATOMIC(&alloc_pool, &release_pool); - co = QSLIST_FIRST(&alloc_pool); - } +#ifdef CONFIG_COROUTINE_POOL + co = QSLIST_FIRST(&alloc_pool); + if (!co) { + /* Slow path; a good place to register the destructor, too. */ + if (!coroutine_pool_cleanup_notifier.notify) { + coroutine_pool_cleanup_notifier.notify = coroutine_pool_cleanup; + qemu_thread_atexit_add(&coroutine_pool_cleanup_notifier); } - if (co) { - QSLIST_REMOVE_HEAD(&alloc_pool, pool_next); - alloc_pool_size--; +#ifdef CONFIG_COROUTINE_RELEASE_POOL + if (release_pool_size > POOL_BATCH_SIZE) { + + /* This is not exact; there could be a little skew between + * release_pool_size and the actual size of release_pool. But + * it is just a heuristic, it does not need to be perfect. + */ + alloc_pool_size = atomic_xchg(&release_pool_size, 0); + QSLIST_MOVE_ATOMIC(&alloc_pool, &release_pool); + co = QSLIST_FIRST(&alloc_pool); } +#endif + } + if (co) { + QSLIST_REMOVE_HEAD(&alloc_pool, pool_next); + alloc_pool_size--; } +#endif if (!co) { co = qemu_coroutine_new(); @@ -84,18 +91,20 @@ static void coroutine_delete(Coroutine *co) { co->caller = NULL; - if (CONFIG_COROUTINE_POOL) { - if (release_pool_size < POOL_BATCH_SIZE * 2) { - QSLIST_INSERT_HEAD_ATOMIC(&release_pool, co, pool_next); - atomic_inc(&release_pool_size); - return; - } - if (alloc_pool_size < POOL_BATCH_SIZE) { - QSLIST_INSERT_HEAD(&alloc_pool, co, pool_next); - alloc_pool_size++; - return; - } +#ifdef CONFIG_COROUTINE_RELEASE_POOL + if (release_pool_size < POOL_BATCH_SIZE * 2) { + QSLIST_INSERT_HEAD_ATOMIC(&release_pool, co, pool_next); + atomic_inc(&release_pool_size); + return; + } +#endif +#ifdef CONFIG_COROUTINE_POOL + if (alloc_pool_size < POOL_BATCH_SIZE) { + QSLIST_INSERT_HEAD(&alloc_pool, co, pool_next); + alloc_pool_size++; + return; } +#endif qemu_coroutine_delete(co); }