From patchwork Mon Jan 21 16:09:50 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paolo Bonzini X-Patchwork-Id: 214230 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 F30A92C007C for ; Tue, 22 Jan 2013 03:50:11 +1100 (EST) Received: from localhost ([::1]:33290 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TxJxk-0002Pv-Kc for incoming@patchwork.ozlabs.org; Mon, 21 Jan 2013 11:11:08 -0500 Received: from eggs.gnu.org ([208.118.235.92]:44992) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TxJx4-0000tZ-QW for qemu-devel@nongnu.org; Mon, 21 Jan 2013 11:10:28 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1TxJx2-0000NW-Nx for qemu-devel@nongnu.org; Mon, 21 Jan 2013 11:10:26 -0500 Received: from mail-ee0-f45.google.com ([74.125.83.45]:54238) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1TxJx2-0000N1-6i for qemu-devel@nongnu.org; Mon, 21 Jan 2013 11:10:24 -0500 Received: by mail-ee0-f45.google.com with SMTP id b57so2885640eek.4 for ; Mon, 21 Jan 2013 08:10:22 -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=EH5CrSMRyU2u+jpQ9hyw2miWQlboZS9efQ4QS5qu4kY=; b=tzgDf2XwqUfOoJQFZw1txKFTnBRin8uYDBQIalqa5xXfu7mojuS+4MbVJnRGEXjLIS WEftc9L85j9cbRx9cRgJ8sIvf3JWP+eLJNUKi4gWLK2S0DRgTeISB4mzzVj48utrUNgI 8/hZqkify4o84ZHfvy07eDw48j4f/QENvdm9fYIg4zKlpijVqxguJok6MdVlwl0s8SrD VaJKSKVxvN3PgDWIBAz/u4i29HRv9vfGcsLSZ4ABGajC9E6/VIrvEhByxUYXoQLtdxCz mmiO3266d9G3t/KaidYjVAfh2EYCxr2y3R6U0tIiznso8o1b7cBHBav79+hDdBlTkAdh GIMw== X-Received: by 10.14.203.3 with SMTP id e3mr26988593eeo.9.1358784622722; Mon, 21 Jan 2013 08:10:22 -0800 (PST) Received: from yakj.lan (93-34-179-137.ip50.fastwebnet.it. [93.34.179.137]) by mx.google.com with ESMTPS id q5sm7892408eeo.17.2013.01.21.08.10.20 (version=TLSv1.2 cipher=RC4-SHA bits=128/128); Mon, 21 Jan 2013 08:10:21 -0800 (PST) From: Paolo Bonzini To: qemu-devel@nongnu.org Date: Mon, 21 Jan 2013 17:09:50 +0100 Message-Id: <1358784590-16288-13-git-send-email-pbonzini@redhat.com> X-Mailer: git-send-email 1.8.1 In-Reply-To: <1358784590-16288-1-git-send-email-pbonzini@redhat.com> References: <1358784590-16288-1-git-send-email-pbonzini@redhat.com> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x [fuzzy] X-Received-From: 74.125.83.45 Cc: kwolf@redhat.com, stefanha@redhat.com Subject: [Qemu-devel] [PATCH v3 12/12] 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 --- v2->v3: Consistently use "chunks" in all related variables. 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 fbebafe..f7ce4d7 100644 --- a/block/mirror.c +++ b/block/mirror.c @@ -139,7 +139,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); @@ -151,45 +151,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 2bfe78d..9d9860c 100644 --- a/trace-events +++ b/trace-events @@ -89,6 +89,7 @@ mirror_iteration_done(void *s, int64_t sector_num, int nb_sectors) "s %p sector_ 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"