From patchwork Tue Jan 22 08:03:15 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paolo Bonzini X-Patchwork-Id: 214429 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id BCBDC2C16D8 for ; Tue, 22 Jan 2013 19:04:31 +1100 (EST) Received: from localhost ([::1]:46066 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TxYqL-0000Zz-TW for incoming@patchwork.ozlabs.org; Tue, 22 Jan 2013 03:04:29 -0500 Received: from eggs.gnu.org ([208.118.235.92]:58572) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TxYpT-0007FL-Ia for qemu-devel@nongnu.org; Tue, 22 Jan 2013 03:03:40 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1TxYpP-00089C-2u for qemu-devel@nongnu.org; Tue, 22 Jan 2013 03:03:34 -0500 Received: from mail-ea0-f178.google.com ([209.85.215.178]:54887) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TxYpO-00088q-P1 for qemu-devel@nongnu.org; Tue, 22 Jan 2013 03:03:30 -0500 Received: by mail-ea0-f178.google.com with SMTP id a14so2884008eaa.9 for ; Tue, 22 Jan 2013 00:03:30 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=x-received:sender:from:to:cc:subject:date:message-id:x-mailer :in-reply-to:references; bh=mNzxLDdXEoUIxaL20ntDV4z4/Yqb0UXoEH4BiknxhDE=; b=Jo0/mQYGbXdkoWYc3fVFELg533up1+wgXKnopFr5PCevvNJamLGyvHhaCOTu2uWiGN FxUDnnL+n/fuATqbXRZNgkvEJdB+TeG1Mqys8ZKStUzCblfKyCBlza+zUKva757SemqJ pzwXT0ZmLdHKxrMBRmlJwN8uZq5aIJkYDO4hP3vy/89ew4mHI2Fqv/+JOuGnRDEgG/mJ drSMC14gZvzPIkNQVuBmy8iWA07HHNNKfOdrcSY1Znp9M2hHwCaZOY2gQIhbShfaA4e3 wr6WL2UQ5TwO+vQOvGA68+4qb9WV9PxA9chUEMV7wX85NpK/EKjAE/pJQHgSHRPNUjKw aklQ== X-Received: by 10.14.224.8 with SMTP id w8mr64226563eep.18.1358841809939; Tue, 22 Jan 2013 00:03:29 -0800 (PST) Received: from yakj.usersys.redhat.com (93-34-179-137.ip50.fastwebnet.it. [93.34.179.137]) by mx.google.com with ESMTPS id t4sm6878087eel.0.2013.01.22.00.03.28 (version=TLSv1.2 cipher=RC4-SHA bits=128/128); Tue, 22 Jan 2013 00:03:29 -0800 (PST) From: Paolo Bonzini To: qemu-devel@nongnu.org Date: Tue, 22 Jan 2013 09:03:15 +0100 Message-Id: <1358841795-24478-5-git-send-email-pbonzini@redhat.com> X-Mailer: git-send-email 1.8.1 In-Reply-To: <1358841795-24478-1-git-send-email-pbonzini@redhat.com> References: <1358841795-24478-1-git-send-email-pbonzini@redhat.com> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x [fuzzy] X-Received-From: 209.85.215.178 Cc: kwolf@redhat.com, stefanha@redhat.com Subject: [Qemu-devel] [PATCH v4 4/4] mirror: support arbitrarily-sized iterations X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Yet another optimization is to extend the mirroring iteration to include more adjacent dirty blocks. This limits the number of I/O operations and makes mirroring efficient even with a small granularity. Most of the infrastructure is already in place; we only need to put a loop around the computation of the origin and sector count of the iteration. Signed-off-by: Paolo Bonzini --- block/mirror.c | 97 ++++++++++++++++++++++++++++++++++++++++------------------ trace-events | 1 + 2 files changed, 68 insertions(+), 30 deletions(-) diff --git a/block/mirror.c b/block/mirror.c index 4696dc8..9347533 100644 --- a/block/mirror.c +++ b/block/mirror.c @@ -140,7 +140,7 @@ static void coroutine_fn mirror_iteration(MirrorBlockJob *s) { BlockDriverState *source = s->common.bs; int nb_sectors, sectors_per_chunk, nb_chunks; - int64_t end, sector_num, chunk_num, next_sector, hbitmap_next_sector; + int64_t end, sector_num, next_chunk, next_sector, hbitmap_next_sector; MirrorOp *op; s->sector_num = hbitmap_iter_next(&s->hbi); @@ -152,45 +152,82 @@ static void coroutine_fn mirror_iteration(MirrorBlockJob *s) } hbitmap_next_sector = s->sector_num; + sector_num = s->sector_num; + sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS; + end = s->common.len >> BDRV_SECTOR_BITS; - /* If we have no backing file yet in the destination, and the cluster size - * is very large, we need to do COW ourselves. The first time a cluster is - * copied, copy it entirely. + /* Extend the QEMUIOVector to include all adjacent blocks that will + * be copied in this operation. + * + * We have to do this if we have no backing file yet in the destination, + * and the cluster size is very large. Then we need to do COW ourselves. + * The first time a cluster is copied, copy it entirely. Note that, + * because both the granularity and the cluster size are powers of two, + * the number of sectors to copy cannot exceed one cluster. * - * Because both the granularity and the cluster size are powers of two, the - * number of sectors to copy cannot exceed one cluster. + * We also want to extend the QEMUIOVector to include more adjacent + * dirty blocks if possible, to limit the number of I/O operations and + * run efficiently even with a small granularity. */ - sector_num = s->sector_num; - sectors_per_chunk = nb_sectors = s->granularity >> BDRV_SECTOR_BITS; - chunk_num = sector_num / sectors_per_chunk; - if (s->cow_bitmap && !test_bit(chunk_num, s->cow_bitmap)) { - trace_mirror_cow(s, sector_num); - bdrv_round_to_clusters(s->target, - sector_num, sectors_per_chunk, - §or_num, &nb_sectors); - - /* The rounding may make us copy sectors before the - * first dirty one. - */ - chunk_num = sector_num / sectors_per_chunk; - } + nb_chunks = 0; + nb_sectors = 0; + next_sector = sector_num; + next_chunk = sector_num / sectors_per_chunk; /* Wait for I/O to this cluster (from a previous iteration) to be done. */ - while (test_bit(chunk_num, s->in_flight_bitmap)) { + while (test_bit(next_chunk, s->in_flight_bitmap)) { trace_mirror_yield_in_flight(s, sector_num, s->in_flight); qemu_coroutine_yield(); } - end = s->common.len >> BDRV_SECTOR_BITS; - nb_sectors = MIN(nb_sectors, end - sector_num); - nb_chunks = (nb_sectors + sectors_per_chunk - 1) / sectors_per_chunk; - while (s->buf_free_count < nb_chunks) { - trace_mirror_yield_buf_busy(s, nb_chunks, s->in_flight); - qemu_coroutine_yield(); - } + do { + int added_sectors, added_chunks; + + if (!bdrv_get_dirty(source, next_sector) || + test_bit(next_chunk, s->in_flight_bitmap)) { + assert(nb_sectors > 0); + break; + } + + added_sectors = sectors_per_chunk; + if (s->cow_bitmap && !test_bit(next_chunk, s->cow_bitmap)) { + bdrv_round_to_clusters(s->target, + next_sector, added_sectors, + &next_sector, &added_sectors); + + /* On the first iteration, the rounding may make us copy + * sectors before the first dirty one. + */ + if (next_sector < sector_num) { + assert(nb_sectors == 0); + sector_num = next_sector; + next_chunk = next_sector / sectors_per_chunk; + } + } + + added_sectors = MIN(added_sectors, end - (sector_num + nb_sectors)); + added_chunks = (added_sectors + sectors_per_chunk - 1) / sectors_per_chunk; + + /* When doing COW, it may happen that there is not enough space for + * a full cluster. Wait if that is the case. + */ + while (nb_chunks == 0 && s->buf_free_count < added_chunks) { + trace_mirror_yield_buf_busy(s, nb_chunks, s->in_flight); + qemu_coroutine_yield(); + } + if (s->buf_free_count < nb_chunks + added_chunks) { + trace_mirror_break_buf_busy(s, nb_chunks, s->in_flight); + break; + } + + /* We have enough free space to copy these sectors. */ + bitmap_set(s->in_flight_bitmap, next_chunk, added_chunks); - /* We have enough free space to copy these sectors. */ - bitmap_set(s->in_flight_bitmap, chunk_num, nb_chunks); + nb_sectors += added_sectors; + nb_chunks += added_chunks; + next_sector += added_sectors; + next_chunk += added_chunks; + } while (next_sector < end); /* Allocate a MirrorOp that is used as an AIO callback. */ op = g_slice_new(MirrorOp); diff --git a/trace-events b/trace-events index ec45608..64d67f9 100644 --- a/trace-events +++ b/trace-events @@ -89,6 +89,7 @@ mirror_iteration_done(void *s, int64_t sector_num, int nb_sectors, int ret) "s % mirror_yield(void *s, int64_t cnt, int buf_free_count, int in_flight) "s %p dirty count %"PRId64" free buffers %d in_flight %d" mirror_yield_in_flight(void *s, int64_t sector_num, int in_flight) "s %p sector_num %"PRId64" in_flight %d" mirror_yield_buf_busy(void *s, int nb_chunks, int in_flight) "s %p requested chunks %d in_flight %d" +mirror_break_buf_busy(void *s, int nb_chunks, int in_flight) "s %p requested chunks %d in_flight %d" # blockdev.c qmp_block_job_cancel(void *job) "job %p"