From nobody Wed May 1 07:53:20 2024 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.zoho.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 1487347307771968.5017748379247; Fri, 17 Feb 2017 08:01:47 -0800 (PST) Received: from localhost ([::1]:54438 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cekye-0002wH-Pd for importer@patchew.org; Fri, 17 Feb 2017 11:01:44 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:45894) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cekxW-0002Kj-1W for qemu-devel@nongnu.org; Fri, 17 Feb 2017 11:00:36 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1cekxS-0008MZ-M8 for qemu-devel@nongnu.org; Fri, 17 Feb 2017 11:00:34 -0500 Received: from mx-v6.kamp.de ([2a02:248:0:51::16]:53177 helo=mx01.kamp.de) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1cekxS-0008Kd-9s for qemu-devel@nongnu.org; Fri, 17 Feb 2017 11:00:30 -0500 Received: (qmail 25502 invoked by uid 89); 17 Feb 2017 16:00:27 -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/23079. avast: 1.2.2/17010300. spamassassin: 3.4.1. Clear:RC:1(195.62.97.28):. Processed in 0.082046 secs); 17 Feb 2017 16:00:27 -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); 17 Feb 2017 16:00:26 -0000 Received: (qmail 2797 invoked from network); 17 Feb 2017 16:00:26 -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; 17 Feb 2017 16:00:26 -0000 Received: by lieven-pc (Postfix, from userid 1000) id 15C3020E78; Fri, 17 Feb 2017 17:00:26 +0100 (CET) X-GL_Whitelist: yes From: Peter Lieven To: qemu-devel@nongnu.org Date: Fri, 17 Feb 2017 17:00:24 +0100 Message-Id: <1487347224-8667-1-git-send-email-pl@kamp.de> X-Mailer: git-send-email 1.9.1 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] [RFC PATCH V4] qemu-img: make convert async 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, famz@redhat.com, qemu-block@nongnu.org, Peter Lieven , mreitz@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail: RSF_0 Z_629925259 SPT_0 Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" this is something I have been thinking about for almost 2 years now. we heavily have the following two use cases when using qemu-img convert. a) reading from NFS and writing to iSCSI for deploying templates b) reading from iSCSI and writing to NFS for backups In both processes we use libiscsi and libnfs so we have no kernel pagecache. As qemu-img convert is implemented with sync operations that means we read one buffer and then write it. No parallelism and each sync request takes as long as it takes until it is completed. This is version 4 of the approach using coroutine worker "threads". So far I have the following runtimes when reading an uncompressed QCOW2 from NFS and writing it to iSCSI (raw): qemu-img (master) nfs -> iscsi 22.8 secs nfs -> ram 11.7 secs ram -> iscsi 12.3 secs qemu-img-async (8 coroutines, in-order write disabled) nfs -> iscsi 11.0 secs nfs -> ram 10.4 secs ram -> iscsi 9.0 secs The following are the runtimes found with different settings between V3 and= V4. This is always the best runtime out of 10 runs when converting from nfs to = iscsi. Please note that in V4 in-order write scenarios show a very high jitter. I = think this is because the get_block_status on the NFS share is delayed by concurr= ent read requests. in-order out-of-order V3 - 16 coroutines 12.4 seconds 11.1 seconds - 8 coroutines 12.2 seconds 11.3 seconds - 4 coroutines 12.5 seconds 11.1 seconds - 2 coroutines 14.8 seconds 14.9 seconds V4 - 32 coroutines 15.9 seconds 11.5 seconds - 16 coroutines 12.5 seconds 11.0 seconds - 8 coroutines 12.9 seconds 11.0 seconds - 4 coroutines 14.1 seconds 11.5 seconds - 2 coroutines 16.9 seconds 13.2 seconds Comments appreciated. Thank you, Peter Signed-off-by: Peter Lieven --- v3->v4: - avoid to prepare a request queue upfront [Kevin] - do not ignore the BLK_BACKING_FILE status [Kevin] - redesign the interface to the read and write routines [Kevin] v2->v3: - updated stats in the commit msg from a host with a better network= card - only wake up the coroutine that is acutally waiting for a write t= o complete. this was not only overhead, but also breaking at least linux AIO. - fix coding style complaints - rename some variables and structs v1->v2: - using coroutine as worker "threads". [Max] - keeping the request queue as otherwise it happens that we wait on BLK_ZERO chunks while keeping the write order. it also avoids redundant calls to get_block_status and helps to skip some conditions for fully allocated imaged (!s->min_spars= e) --- qemu-img.c | 260 ++++++++++++++++++++++++++++++++++++++++++++-------------= ---- 1 file changed, 187 insertions(+), 73 deletions(-) diff --git a/qemu-img.c b/qemu-img.c index cff22e3..6bac980 100644 --- a/qemu-img.c +++ b/qemu-img.c @@ -1448,6 +1448,8 @@ enum ImgConvertBlockStatus { BLK_BACKING_FILE, }; =20 +#define MAX_COROUTINES 16 + typedef struct ImgConvertState { BlockBackend **src; int64_t *src_sectors; @@ -1455,15 +1457,25 @@ typedef struct ImgConvertState { int64_t src_cur_offset; int64_t total_sectors; int64_t allocated_sectors; + int64_t allocated_done; + int64_t sector_num; + int64_t wr_offs; enum ImgConvertBlockStatus status; int64_t sector_next_status; BlockBackend *target; bool has_zero_init; bool compressed; bool target_has_backing; + bool wr_in_order; int min_sparse; size_t cluster_sectors; size_t buf_sectors; + int num_coroutines; + int running_coroutines; + Coroutine *co[MAX_COROUTINES]; + int64_t wait_sector_num[MAX_COROUTINES]; + CoMutex lock; + int ret; } ImgConvertState; =20 static void convert_select_part(ImgConvertState *s, int64_t sector_num) @@ -1544,11 +1556,12 @@ static int convert_iteration_sectors(ImgConvertStat= e *s, int64_t sector_num) return n; } =20 -static int convert_read(ImgConvertState *s, int64_t sector_num, int nb_sec= tors, - uint8_t *buf) +static int convert_co_read(ImgConvertState *s, int64_t sector_num, + int nb_sectors, uint8_t *buf) { - int n; - int ret; + int n, ret; + QEMUIOVector qiov; + struct iovec iov; =20 assert(nb_sectors <=3D s->buf_sectors); while (nb_sectors > 0) { @@ -1563,9 +1576,13 @@ static int convert_read(ImgConvertState *s, int64_t = sector_num, int nb_sectors, bs_sectors =3D s->src_sectors[s->src_cur]; =20 n =3D MIN(nb_sectors, bs_sectors - (sector_num - s->src_cur_offset= )); - ret =3D blk_pread(blk, - (sector_num - s->src_cur_offset) << BDRV_SECTOR_BI= TS, - buf, n << BDRV_SECTOR_BITS); + iov.iov_base =3D buf; + iov.iov_len =3D n << BDRV_SECTOR_BITS; + qemu_iovec_init_external(&qiov, &iov, 1); + + ret =3D blk_co_preadv( + blk, (sector_num - s->src_cur_offset) << BDRV_SECTOR_BITS, + n << BDRV_SECTOR_BITS, &qiov, 0); if (ret < 0) { return ret; } @@ -1578,15 +1595,18 @@ static int convert_read(ImgConvertState *s, int64_t= sector_num, int nb_sectors, return 0; } =20 -static int convert_write(ImgConvertState *s, int64_t sector_num, int nb_se= ctors, - const uint8_t *buf) + +static int convert_co_write(ImgConvertState *s, int64_t sector_num, + int nb_sectors, uint8_t *buf, + enum ImgConvertBlockStatus status) { int ret; + QEMUIOVector qiov; + struct iovec iov; =20 while (nb_sectors > 0) { int n =3D nb_sectors; - - switch (s->status) { + switch (status) { case BLK_BACKING_FILE: /* If we have a backing file, leave clusters unallocated that = are * unallocated in the source image, so that the backing file is @@ -1607,9 +1627,13 @@ static int convert_write(ImgConvertState *s, int64_t= sector_num, int nb_sectors, break; } =20 - ret =3D blk_pwrite_compressed(s->target, - sector_num << BDRV_SECTOR_BITS, - buf, n << BDRV_SECTOR_BITS); + iov.iov_base =3D buf; + iov.iov_len =3D n << BDRV_SECTOR_BITS; + qemu_iovec_init_external(&qiov, &iov, 1); + + ret =3D blk_co_pwritev(s->target, sector_num << BDRV_SECTO= R_BITS, + n << BDRV_SECTOR_BITS, &qiov, + BDRV_REQ_WRITE_COMPRESSED); if (ret < 0) { return ret; } @@ -1622,8 +1646,12 @@ static int convert_write(ImgConvertState *s, int64_t= sector_num, int nb_sectors, if (!s->min_sparse || is_allocated_sectors_min(buf, n, &n, s->min_sparse)) { - ret =3D blk_pwrite(s->target, sector_num << BDRV_SECTOR_BI= TS, - buf, n << BDRV_SECTOR_BITS, 0); + iov.iov_base =3D buf; + iov.iov_len =3D n << BDRV_SECTOR_BITS; + qemu_iovec_init_external(&qiov, &iov, 1); + + ret =3D blk_co_pwritev(s->target, sector_num << BDRV_SECTO= R_BITS, + n << BDRV_SECTOR_BITS, &qiov, 0); if (ret < 0) { return ret; } @@ -1635,8 +1663,9 @@ static int convert_write(ImgConvertState *s, int64_t = sector_num, int nb_sectors, if (s->has_zero_init) { break; } - ret =3D blk_pwrite_zeroes(s->target, sector_num << BDRV_SECTOR= _BITS, - n << BDRV_SECTOR_BITS, 0); + ret =3D blk_co_pwrite_zeroes(s->target, + sector_num << BDRV_SECTOR_BITS, + n << BDRV_SECTOR_BITS, 0); if (ret < 0) { return ret; } @@ -1651,12 +1680,117 @@ static int convert_write(ImgConvertState *s, int64= _t sector_num, int nb_sectors, return 0; } =20 -static int convert_do_copy(ImgConvertState *s) +static void convert_co_do_copy(void *opaque) { + ImgConvertState *s =3D opaque; uint8_t *buf =3D NULL; - int64_t sector_num, allocated_done; - int ret; - int n; + int ret, i; + int index =3D -1; + + for (i =3D 0; i < s->num_coroutines; i++) { + if (s->co[i] =3D=3D qemu_coroutine_self()) { + index =3D i; + break; + } + } + assert(index >=3D 0); + + s->running_coroutines++; + buf =3D blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE); + + while (1) { + int n; + int64_t sector_num; + enum ImgConvertBlockStatus status; + + qemu_co_mutex_lock(&s->lock); + if (s->ret !=3D -EINPROGRESS || s->sector_num >=3D s->total_sector= s) { + qemu_co_mutex_unlock(&s->lock); + goto out; + } + n =3D convert_iteration_sectors(s, s->sector_num); + if (n < 0) { + qemu_co_mutex_unlock(&s->lock); + s->ret =3D n; + goto out; + } + /* safe current sector and allocation status to local variables */ + sector_num =3D s->sector_num; + status =3D s->status; + if (!s->min_sparse && s->status =3D=3D BLK_ZERO) { + n =3D MIN(n, s->buf_sectors); + } + /* increment global sector counter so that other coroutines can + * already continue reading beyond this request */ + s->sector_num +=3D n; + qemu_co_mutex_unlock(&s->lock); + + if (status =3D=3D BLK_DATA || (!s->min_sparse && s->status =3D=3D = BLK_ZERO)) { + s->allocated_done +=3D n; + qemu_progress_print(100.0 * s->allocated_done / + s->allocated_sectors, 0); + } + + if (status =3D=3D BLK_DATA) { + ret =3D convert_co_read(s, sector_num, n, buf); + if (ret < 0) { + error_report("error while reading sector %" PRId64 + ": %s", sector_num, strerror(-ret)); + s->ret =3D ret; + goto out; + } + } else if (!s->min_sparse && s->status =3D=3D BLK_ZERO) { + status =3D BLK_DATA; + memset(buf, 0x00, n * BDRV_SECTOR_SIZE); + } + + if (s->wr_in_order) { + /* keep writes in order */ + while (s->wr_offs !=3D sector_num) { + if (s->ret !=3D -EINPROGRESS) { + goto out; + } + s->wait_sector_num[index] =3D sector_num; + qemu_coroutine_yield(); + } + s->wait_sector_num[index] =3D -1; + } + + ret =3D convert_co_write(s, sector_num, n, buf, status); + if (ret < 0) { + error_report("error while writing sector %" PRId64 + ": %s", sector_num, strerror(-ret)); + s->ret =3D ret; + goto out; + } + + if (s->wr_in_order) { + /* reenter the coroutine that might have waited + * for this write to complete */ + s->wr_offs =3D sector_num + n; + for (i =3D 0; i < s->num_coroutines; i++) { + if (s->co[i] && s->wait_sector_num[i] =3D=3D s->wr_offs) { + qemu_coroutine_enter(s->co[i]); + break; + } + } + } + } + +out: + qemu_vfree(buf); + s->co[index] =3D NULL; + s->running_coroutines--; + if (!s->running_coroutines && s->ret =3D=3D -EINPROGRESS) { + /* the convert job finished successfully */ + s->ret =3D 0; + } +} + +static int convert_do_copy(ImgConvertState *s) +{ + int ret, i, n; + int64_t sector_num =3D 0; =20 /* Check whether we have zero initialisation or can get it efficiently= */ s->has_zero_init =3D s->min_sparse && !s->target_has_backing @@ -1677,21 +1811,15 @@ static int convert_do_copy(ImgConvertState *s) if (s->compressed) { if (s->cluster_sectors <=3D 0 || s->cluster_sectors > s->buf_secto= rs) { error_report("invalid cluster size"); - ret =3D -EINVAL; - goto fail; + return -EINVAL; } s->buf_sectors =3D s->cluster_sectors; } - buf =3D blk_blockalign(s->target, s->buf_sectors * BDRV_SECTOR_SIZE); =20 - /* Calculate allocated sectors for progress */ - s->allocated_sectors =3D 0; - sector_num =3D 0; while (sector_num < s->total_sectors) { n =3D convert_iteration_sectors(s, sector_num); if (n < 0) { - ret =3D n; - goto fail; + return n; } if (s->status =3D=3D BLK_DATA || (!s->min_sparse && s->status =3D= =3D BLK_ZERO)) { @@ -1704,58 +1832,28 @@ static int convert_do_copy(ImgConvertState *s) s->src_cur =3D 0; s->src_cur_offset =3D 0; s->sector_next_status =3D 0; + s->ret =3D -EINPROGRESS; =20 - sector_num =3D 0; - allocated_done =3D 0; - - while (sector_num < s->total_sectors) { - n =3D convert_iteration_sectors(s, sector_num); - if (n < 0) { - ret =3D n; - goto fail; - } - if (s->status =3D=3D BLK_DATA || (!s->min_sparse && s->status =3D= =3D BLK_ZERO)) - { - allocated_done +=3D n; - qemu_progress_print(100.0 * allocated_done / s->allocated_sect= ors, - 0); - } - - if (s->status =3D=3D BLK_DATA) { - ret =3D convert_read(s, sector_num, n, buf); - if (ret < 0) { - error_report("error while reading sector %" PRId64 - ": %s", sector_num, strerror(-ret)); - goto fail; - } - } else if (!s->min_sparse && s->status =3D=3D BLK_ZERO) { - n =3D MIN(n, s->buf_sectors); - memset(buf, 0, n * BDRV_SECTOR_SIZE); - s->status =3D BLK_DATA; - } - - ret =3D convert_write(s, sector_num, n, buf); - if (ret < 0) { - error_report("error while writing sector %" PRId64 - ": %s", sector_num, strerror(-ret)); - goto fail; - } + qemu_co_mutex_init(&s->lock); + for (i =3D 0; i < s->num_coroutines; i++) { + s->co[i] =3D qemu_coroutine_create(convert_co_do_copy, s); + s->wait_sector_num[i] =3D -1; + qemu_coroutine_enter(s->co[i]); + } =20 - sector_num +=3D n; + while (s->ret =3D=3D -EINPROGRESS) { + main_loop_wait(false); } =20 - if (s->compressed) { + if (s->compressed && !s->ret) { /* signal EOF to align */ ret =3D blk_pwrite_compressed(s->target, 0, NULL, 0); if (ret < 0) { - goto fail; + return ret; } } =20 - ret =3D 0; -fail: - qemu_vfree(buf); - return ret; + return s->ret; } =20 static int img_convert(int argc, char **argv) @@ -1783,6 +1881,8 @@ static int img_convert(int argc, char **argv) QemuOpts *sn_opts =3D NULL; ImgConvertState state; bool image_opts =3D false; + bool wr_in_order =3D true; + int num_coroutines =3D 8; =20 fmt =3D NULL; out_fmt =3D "raw"; @@ -1798,7 +1898,7 @@ static int img_convert(int argc, char **argv) {"image-opts", no_argument, 0, OPTION_IMAGE_OPTS}, {0, 0, 0, 0} }; - c =3D getopt_long(argc, argv, "hf:O:B:ce6o:s:l:S:pt:T:qn", + c =3D getopt_long(argc, argv, "hf:O:B:ce6o:s:l:S:pt:T:qnm:W", long_options, NULL); if (c =3D=3D -1) { break; @@ -1890,6 +1990,18 @@ static int img_convert(int argc, char **argv) case 'n': skip_create =3D 1; break; + case 'm': + num_coroutines =3D atoi(optarg); + if (num_coroutines > MAX_COROUTINES) { + error_report("Maximum allowed number of coroutines is %d", + MAX_COROUTINES); + ret =3D -1; + goto fail_getopt; + } + break; + case 'W': + wr_in_order =3D false; + break; case OPTION_OBJECT: opts =3D qemu_opts_parse_noisily(&qemu_object_opts, optarg, true); @@ -2149,6 +2261,8 @@ static int img_convert(int argc, char **argv) .min_sparse =3D min_sparse, .cluster_sectors =3D cluster_sectors, .buf_sectors =3D bufsectors, + .wr_in_order =3D wr_in_order, + .num_coroutines =3D num_coroutines, }; ret =3D convert_do_copy(&state); =20 --=20 1.9.1