From nobody Thu Nov 6 22:53:22 2025 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 1544613738483760.0159148689897; Wed, 12 Dec 2018 03:22:18 -0800 (PST) Received: from localhost ([::1]:43910 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gX2an-0001sy-Hs for importer@patchew.org; Wed, 12 Dec 2018 06:22:17 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:34985) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gX2VK-0006qm-PN for qemu-devel@nongnu.org; Wed, 12 Dec 2018 06:16:39 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gX2VJ-0003L9-Mu for qemu-devel@nongnu.org; Wed, 12 Dec 2018 06:16:38 -0500 Received: from smtp03.citrix.com ([162.221.156.55]:43645) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1gX2VH-0002eF-Dh; Wed, 12 Dec 2018 06:16:35 -0500 X-IronPort-AV: E=Sophos;i="5.56,344,1539648000"; d="scan'208";a="73098904" From: Paul Durrant To: , , Date: Wed, 12 Dec 2018 11:16:24 +0000 Message-ID: <1544613386-22045-2-git-send-email-paul.durrant@citrix.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1544613386-22045-1-git-send-email-paul.durrant@citrix.com> References: <1544613386-22045-1-git-send-email-paul.durrant@citrix.com> MIME-Version: 1.0 X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 162.221.156.55 Subject: [Qemu-devel] [PATCH v3 1/3] xen-block: improve batching behaviour 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: Kevin Wolf , Stefano Stabellini , Tim Smith , Max Reitz , Paul Durrant , Stefan Hajnoczi , Anthony Perard Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Tim Smith When I/O consists of many small requests, performance is improved by batching them together in a single io_submit() call. When there are relatively few requests, the extra overhead is not worth it. This introduces a check to start batching I/O requests via blk_io_plug()/ blk_io_unplug() in an amount proportional to the number which were already in flight at the time we started reading the ring. Signed-off-by: Tim Smith Re-based and commit comment adjusted. Signed-off-by: Paul Durrant Acked-by: Anthony PERARD --- Cc: Stefan Hajnoczi Cc: Stefano Stabellini Cc: Anthony Perard Cc: Kevin Wolf Cc: Max Reitz --- hw/block/dataplane/xen-block.c | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/hw/block/dataplane/xen-block.c b/hw/block/dataplane/xen-block.c index 80df7da..db17ab5 100644 --- a/hw/block/dataplane/xen-block.c +++ b/hw/block/dataplane/xen-block.c @@ -528,10 +528,18 @@ static int xen_block_get_request(XenBlockDataPlane *d= ataplane, return 0; } =20 +/* + * Threshold of in-flight requests above which we will start using + * blk_io_plug()/blk_io_unplug() to batch requests. + */ +#define IO_PLUG_THRESHOLD 1 + static void xen_block_handle_requests(XenBlockDataPlane *dataplane) { RING_IDX rc, rp; XenBlockRequest *request; + int inflight_atstart =3D dataplane->requests_inflight; + int batched =3D 0; =20 dataplane->more_work =3D 0; =20 @@ -540,6 +548,18 @@ static void xen_block_handle_requests(XenBlockDataPlan= e *dataplane) xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ =20 xen_block_send_response_all(dataplane); + /* + * If there was more than IO_PLUG_THRESHOLD requests in flight + * when we got here, this is an indication that there the bottleneck + * is below us, so it's worth beginning to batch up I/O requests + * rather than submitting them immediately. The maximum number + * of requests we're willing to batch is the number already in + * flight, so it can grow up to max_requests when the bottleneck + * is below us. + */ + if (inflight_atstart > IO_PLUG_THRESHOLD) { + blk_io_plug(dataplane->blk); + } while (rc !=3D rp) { /* pull request from ring */ if (RING_REQUEST_CONS_OVERFLOW(&dataplane->rings.common, rc)) { @@ -585,7 +605,22 @@ static void xen_block_handle_requests(XenBlockDataPlan= e *dataplane) continue; } =20 + if (inflight_atstart > IO_PLUG_THRESHOLD && + batched >=3D inflight_atstart) { + blk_io_unplug(dataplane->blk); + } xen_block_do_aio(request); + if (inflight_atstart > IO_PLUG_THRESHOLD) { + if (batched >=3D inflight_atstart) { + blk_io_plug(dataplane->blk); + batched =3D 0; + } else { + batched++; + } + } + } + if (inflight_atstart > IO_PLUG_THRESHOLD) { + blk_io_unplug(dataplane->blk); } =20 if (dataplane->more_work && --=20 2.1.4 From nobody Thu Nov 6 22:53:22 2025 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (208.118.235.17 [208.118.235.17]) by mx.zohomail.com with SMTPS id 1544613504874854.974249924257; Wed, 12 Dec 2018 03:18:24 -0800 (PST) Received: from localhost ([::1]:43886 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gX2X1-00080H-O3 for importer@patchew.org; Wed, 12 Dec 2018 06:18:23 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:34965) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gX2VJ-0006p8-Aq for qemu-devel@nongnu.org; Wed, 12 Dec 2018 06:16:38 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gX2VI-0003BZ-6R for qemu-devel@nongnu.org; Wed, 12 Dec 2018 06:16:37 -0500 Received: from smtp03.citrix.com ([162.221.156.55]:43645) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1gX2VD-0002eF-1W; Wed, 12 Dec 2018 06:16:31 -0500 X-IronPort-AV: E=Sophos;i="5.56,344,1539648000"; d="scan'208";a="73098899" From: Paul Durrant To: , , Date: Wed, 12 Dec 2018 11:16:25 +0000 Message-ID: <1544613386-22045-3-git-send-email-paul.durrant@citrix.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1544613386-22045-1-git-send-email-paul.durrant@citrix.com> References: <1544613386-22045-1-git-send-email-paul.durrant@citrix.com> MIME-Version: 1.0 X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 162.221.156.55 Subject: [Qemu-devel] [PATCH v3 2/3] xen-block: improve response latency 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: Kevin Wolf , Stefano Stabellini , Tim Smith , Max Reitz , Paul Durrant , Stefan Hajnoczi , Anthony Perard Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Tim Smith If the I/O ring is full, the guest cannot send any more requests until some responses are sent. Only sending all available responses just before checking for new work does not leave much time for the guest to supply new work, so this will cause stalls if the ring gets full. Also, not completing reads as soon as possible adds latency to the guest. To alleviate that, complete IO requests as soon as they come back. xen_block_send_response() already returns a value indicating whether a notify should be sent, which is all the batching we need. Signed-off-by: Tim Smith Re-based and commit comment adjusted. Signed-off-by: Paul Durrant Acked-by: Anthony PERARD --- Cc: Stefan Hajnoczi Cc: Stefano Stabellini Cc: Anthony Perard Cc: Kevin Wolf Cc: Max Reitz --- hw/block/dataplane/xen-block.c | 56 ++++++++++++++------------------------= ---- 1 file changed, 18 insertions(+), 38 deletions(-) diff --git a/hw/block/dataplane/xen-block.c b/hw/block/dataplane/xen-block.c index db17ab5..b4ff2e3 100644 --- a/hw/block/dataplane/xen-block.c +++ b/hw/block/dataplane/xen-block.c @@ -55,11 +55,9 @@ struct XenBlockDataPlane { blkif_back_rings_t rings; int more_work; QLIST_HEAD(inflight_head, XenBlockRequest) inflight; - QLIST_HEAD(finished_head, XenBlockRequest) finished; QLIST_HEAD(freelist_head, XenBlockRequest) freelist; int requests_total; int requests_inflight; - int requests_finished; unsigned int max_requests; BlockBackend *blk; QEMUBH *bh; @@ -116,12 +114,10 @@ static void xen_block_finish_request(XenBlockRequest = *request) XenBlockDataPlane *dataplane =3D request->dataplane; =20 QLIST_REMOVE(request, list); - QLIST_INSERT_HEAD(&dataplane->finished, request, list); dataplane->requests_inflight--; - dataplane->requests_finished++; } =20 -static void xen_block_release_request(XenBlockRequest *request, bool finis= h) +static void xen_block_release_request(XenBlockRequest *request) { XenBlockDataPlane *dataplane =3D request->dataplane; =20 @@ -129,11 +125,7 @@ static void xen_block_release_request(XenBlockRequest = *request, bool finish) reset_request(request); request->dataplane =3D dataplane; QLIST_INSERT_HEAD(&dataplane->freelist, request, list); - if (finish) { - dataplane->requests_finished--; - } else { - dataplane->requests_inflight--; - } + dataplane->requests_inflight--; } =20 /* @@ -248,6 +240,7 @@ static int xen_block_copy_request(XenBlockRequest *requ= est) } =20 static int xen_block_do_aio(XenBlockRequest *request); +static int xen_block_send_response(XenBlockRequest *request); =20 static void xen_block_complete_aio(void *opaque, int ret) { @@ -312,6 +305,18 @@ static void xen_block_complete_aio(void *opaque, int r= et) default: break; } + if (xen_block_send_response(request)) { + Error *local_err =3D NULL; + + xen_device_notify_event_channel(dataplane->xendev, + dataplane->event_channel, + &local_err); + if (local_err) { + error_report_err(local_err); + } + } + xen_block_release_request(request); + qemu_bh_schedule(dataplane->bh); =20 done: @@ -419,7 +424,7 @@ err: return -1; } =20 -static int xen_block_send_response_one(XenBlockRequest *request) +static int xen_block_send_response(XenBlockRequest *request) { XenBlockDataPlane *dataplane =3D request->dataplane; int send_notify =3D 0; @@ -474,29 +479,6 @@ static int xen_block_send_response_one(XenBlockRequest= *request) return send_notify; } =20 -/* walk finished list, send outstanding responses, free requests */ -static void xen_block_send_response_all(XenBlockDataPlane *dataplane) -{ - XenBlockRequest *request; - int send_notify =3D 0; - - while (!QLIST_EMPTY(&dataplane->finished)) { - request =3D QLIST_FIRST(&dataplane->finished); - send_notify +=3D xen_block_send_response_one(request); - xen_block_release_request(request, true); - } - if (send_notify) { - Error *local_err =3D NULL; - - xen_device_notify_event_channel(dataplane->xendev, - dataplane->event_channel, - &local_err); - if (local_err) { - error_report_err(local_err); - } - } -} - static int xen_block_get_request(XenBlockDataPlane *dataplane, XenBlockRequest *request, RING_IDX rc) { @@ -547,7 +529,6 @@ static void xen_block_handle_requests(XenBlockDataPlane= *dataplane) rp =3D dataplane->rings.common.sring->req_prod; xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ =20 - xen_block_send_response_all(dataplane); /* * If there was more than IO_PLUG_THRESHOLD requests in flight * when we got here, this is an indication that there the bottleneck @@ -591,7 +572,7 @@ static void xen_block_handle_requests(XenBlockDataPlane= *dataplane) break; }; =20 - if (xen_block_send_response_one(request)) { + if (xen_block_send_response(request)) { Error *local_err =3D NULL; =20 xen_device_notify_event_channel(dataplane->xendev, @@ -601,7 +582,7 @@ static void xen_block_handle_requests(XenBlockDataPlane= *dataplane) error_report_err(local_err); } } - xen_block_release_request(request, false); + xen_block_release_request(request); continue; } =20 @@ -657,7 +638,6 @@ XenBlockDataPlane *xen_block_dataplane_create(XenDevice= *xendev, dataplane->file_size =3D blk_getlength(dataplane->blk); =20 QLIST_INIT(&dataplane->inflight); - QLIST_INIT(&dataplane->finished); QLIST_INIT(&dataplane->freelist); =20 if (iothread) { --=20 2.1.4 From nobody Thu Nov 6 22:53:22 2025 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) client-ip=208.118.235.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Authentication-Results: mx.zohomail.com; spf=pass (zoho.com: domain of gnu.org designates 208.118.235.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) by mx.zohomail.com with SMTPS id 1544613593248596.0882117980921; Wed, 12 Dec 2018 03:19:53 -0800 (PST) Received: from localhost ([::1]:43897 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gX2YS-0000U5-6M for importer@patchew.org; Wed, 12 Dec 2018 06:19:52 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:34977) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gX2VK-0006q9-4k for qemu-devel@nongnu.org; Wed, 12 Dec 2018 06:16:39 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gX2VJ-0003HK-2X for qemu-devel@nongnu.org; Wed, 12 Dec 2018 06:16:38 -0500 Received: from smtp03.citrix.com ([162.221.156.55]:43645) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1gX2VG-0002eF-NQ; Wed, 12 Dec 2018 06:16:34 -0500 X-IronPort-AV: E=Sophos;i="5.56,344,1539648000"; d="scan'208";a="73098903" From: Paul Durrant To: , , Date: Wed, 12 Dec 2018 11:16:26 +0000 Message-ID: <1544613386-22045-4-git-send-email-paul.durrant@citrix.com> X-Mailer: git-send-email 2.1.4 In-Reply-To: <1544613386-22045-1-git-send-email-paul.durrant@citrix.com> References: <1544613386-22045-1-git-send-email-paul.durrant@citrix.com> MIME-Version: 1.0 X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 162.221.156.55 Subject: [Qemu-devel] [PATCH v3 3/3] xen-block: avoid repeated memory allocation 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: Kevin Wolf , Stefano Stabellini , Tim Smith , Max Reitz , Paul Durrant , Stefan Hajnoczi , Anthony Perard Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Tim Smith The xen-block dataplane currently allocates memory to hold the data for each request as that request is used, and frees it afterwards. Because it requires page-aligned blocks, this interacts poorly with non-page- aligned allocations and balloons the heap. Instead, allocate the maximum possible buffer size required for the protocol, which is BLKIF_MAX_SEGMENTS_PER_REQUEST (currently 11) pages when the request structure is created, and keep that buffer until it is destroyed. Since the requests are re-used via a free list, this should actually improve memory usage. Signed-off-by: Tim Smith Re-based and commit comment adjusted. Signed-off-by: Paul Durrant Acked-by: Anthony PERARD --- Cc: Stefan Hajnoczi Cc: Stefano Stabellini Cc: Anthony Perard Cc: Kevin Wolf Cc: Max Reitz --- hw/block/dataplane/xen-block.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/hw/block/dataplane/xen-block.c b/hw/block/dataplane/xen-block.c index b4ff2e3..21804d7 100644 --- a/hw/block/dataplane/xen-block.c +++ b/hw/block/dataplane/xen-block.c @@ -70,7 +70,6 @@ static void reset_request(XenBlockRequest *request) memset(&request->req, 0, sizeof(request->req)); request->status =3D 0; request->start =3D 0; - request->buf =3D NULL; request->size =3D 0; request->presync =3D 0; =20 @@ -95,6 +94,14 @@ static XenBlockRequest *xen_block_start_request(XenBlock= DataPlane *dataplane) /* allocate new struct */ request =3D g_malloc0(sizeof(*request)); request->dataplane =3D dataplane; + /* + * We cannot need more pages per requests than this, and since we + * re-use requests, allocate the memory once here. It will be freed + * xen_block_dataplane_destroy() when the request list is freed. + */ + request->buf =3D qemu_memalign(XC_PAGE_SIZE, + BLKIF_MAX_SEGMENTS_PER_REQUEST * + XC_PAGE_SIZE); dataplane->requests_total++; qemu_iovec_init(&request->v, 1); } else { @@ -272,14 +279,12 @@ static void xen_block_complete_aio(void *opaque, int = ret) if (ret =3D=3D 0) { xen_block_copy_request(request); } - qemu_vfree(request->buf); break; case BLKIF_OP_WRITE: case BLKIF_OP_FLUSH_DISKCACHE: if (!request->req.nr_segments) { break; } - qemu_vfree(request->buf); break; default: break; @@ -360,12 +365,10 @@ static int xen_block_do_aio(XenBlockRequest *request) { XenBlockDataPlane *dataplane =3D request->dataplane; =20 - request->buf =3D qemu_memalign(XC_PAGE_SIZE, request->size); if (request->req.nr_segments && (request->req.operation =3D=3D BLKIF_OP_WRITE || request->req.operation =3D=3D BLKIF_OP_FLUSH_DISKCACHE) && xen_block_copy_request(request)) { - qemu_vfree(request->buf); goto err; } =20 @@ -665,6 +668,7 @@ void xen_block_dataplane_destroy(XenBlockDataPlane *dat= aplane) request =3D QLIST_FIRST(&dataplane->freelist); QLIST_REMOVE(request, list); qemu_iovec_destroy(&request->v); + qemu_vfree(request->buf); g_free(request); } =20 --=20 2.1.4