From nobody Thu May 16 07:34:32 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1658563105562257.3183098837384; Sat, 23 Jul 2022 00:58:25 -0700 (PDT) Received: from localhost ([::1]:51798 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oFA1o-00016q-Hj for importer@patchew.org; Sat, 23 Jul 2022 03:58:24 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:36878) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1oF9tT-0001YH-RE for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:49 -0400 Received: from prt-mail.chinatelecom.cn ([42.123.76.222]:53041 helo=chinatelecom.cn) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oF9tN-0000Pm-9J for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:45 -0400 Received: from clientip-125.69.42.4 (unknown [172.18.0.218]) by chinatelecom.cn (HERMES) with SMTP id 44EC82800BC; Sat, 23 Jul 2022 15:49:26 +0800 (CST) Received: from ([172.18.0.218]) by app0025 with ESMTP id 8657caa07b794076a2f1683504310c19 for qemu-devel@nongnu.org; Sat, 23 Jul 2022 15:49:29 CST HMM_SOURCE_IP: 172.18.0.218:34686.1353564676 HMM_ATTACHE_NUM: 0000 HMM_SOURCE_TYPE: SMTP X-189-SAVE-TO-SEND: +huangy81@chinatelecom.cn X-Transaction-ID: 8657caa07b794076a2f1683504310c19 X-Real-From: huangy81@chinatelecom.cn X-Receive-IP: 172.18.0.218 X-MEDUSA-Status: 0 From: huangy81@chinatelecom.cn To: qemu-devel Cc: Juan Quintela , "Dr. David Alan Gilbert" , Eric Blake , Markus Armbruster , Thomas Huth , Laurent Vivier , Paolo Bonzini , peterx@redhat.com, "Daniel P. Berrange" , =?UTF-8?q?Hyman=20Huang=28=E9=BB=84=E5=8B=87=29?= Subject: [PATCH 1/8] qapi/migration: Introduce x-vcpu-dirty-limit-period parameter Date: Sat, 23 Jul 2022 15:49:13 +0800 Message-Id: <22a4776fc05a4174cb07728e0350430a420e2b9c.1658561555.git.huangy81@chinatelecom.cn> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=42.123.76.222; envelope-from=huangy81@chinatelecom.cn; helo=chinatelecom.cn X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZM-MESSAGEID: 1658563107131100001 From: Hyman Huang(=E9=BB=84=E5=8B=87) Introduce "x-vcpu-dirty-limit-period" migration experimental parameter, which is used to make dirtyrate calculation period configurable. Signed-off-by: Hyman Huang(=E9=BB=84=E5=8B=87) --- migration/migration.c | 16 ++++++++++++++++ monitor/hmp-cmds.c | 8 ++++++++ qapi/migration.json | 31 ++++++++++++++++++++++++------- 3 files changed, 48 insertions(+), 7 deletions(-) diff --git a/migration/migration.c b/migration/migration.c index e03f698..7b19f85 100644 --- a/migration/migration.c +++ b/migration/migration.c @@ -116,6 +116,8 @@ #define DEFAULT_MIGRATE_ANNOUNCE_ROUNDS 5 #define DEFAULT_MIGRATE_ANNOUNCE_STEP 100 =20 +#define DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD 500 /* ms */ + static NotifierList migration_state_notifiers =3D NOTIFIER_LIST_INITIALIZER(migration_state_notifiers); =20 @@ -962,6 +964,9 @@ MigrationParameters *qmp_query_migrate_parameters(Error= **errp) s->parameters.block_bitmap_mapping); } =20 + params->has_x_vcpu_dirty_limit_period =3D true; + params->x_vcpu_dirty_limit_period =3D s->parameters.x_vcpu_dirty_limit= _period; + return params; } =20 @@ -1662,6 +1667,10 @@ static void migrate_params_test_apply(MigrateSetPara= meters *params, dest->has_block_bitmap_mapping =3D true; dest->block_bitmap_mapping =3D params->block_bitmap_mapping; } + + if (params->has_x_vcpu_dirty_limit_period) { + dest->x_vcpu_dirty_limit_period =3D params->x_vcpu_dirty_limit_per= iod; + } } =20 static void migrate_params_apply(MigrateSetParameters *params, Error **err= p) @@ -1784,6 +1793,10 @@ static void migrate_params_apply(MigrateSetParameter= s *params, Error **errp) QAPI_CLONE(BitmapMigrationNodeAliasList, params->block_bitmap_mapping); } + if (params->has_x_vcpu_dirty_limit_period) { + s->parameters.x_vcpu_dirty_limit_period =3D + params->x_vcpu_dirty_limit_period; + } } =20 void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp) @@ -4384,6 +4397,9 @@ static Property migration_properties[] =3D { DEFINE_PROP_STRING("tls-creds", MigrationState, parameters.tls_creds), DEFINE_PROP_STRING("tls-hostname", MigrationState, parameters.tls_host= name), DEFINE_PROP_STRING("tls-authz", MigrationState, parameters.tls_authz), + DEFINE_PROP_UINT64("x-vcpu-dirty-limit-period", MigrationState, + parameters.x_vcpu_dirty_limit_period, + DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD), =20 /* Migration capabilities */ DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE), diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c index a6dc79e..64c996c 100644 --- a/monitor/hmp-cmds.c +++ b/monitor/hmp-cmds.c @@ -532,6 +532,10 @@ void hmp_info_migrate_parameters(Monitor *mon, const Q= Dict *qdict) } } } + + monitor_printf(mon, "%s: %" PRIu64 " ms\n", + MigrationParameter_str(MIGRATION_PARAMETER_X_VCPU_DIRTY_LIMIT_PERI= OD), + params->x_vcpu_dirty_limit_period); } =20 qapi_free_MigrationParameters(params); @@ -1351,6 +1355,10 @@ void hmp_migrate_set_parameter(Monitor *mon, const Q= Dict *qdict) error_setg(&err, "The block-bitmap-mapping parameter can only be s= et " "through QMP"); break; + case MIGRATION_PARAMETER_X_VCPU_DIRTY_LIMIT_PERIOD: + p->has_x_vcpu_dirty_limit_period =3D true; + visit_type_size(v, param, &p->x_vcpu_dirty_limit_period, &err); + break; default: assert(0); } diff --git a/qapi/migration.json b/qapi/migration.json index 81185d4..332c087 100644 --- a/qapi/migration.json +++ b/qapi/migration.json @@ -776,8 +776,12 @@ # block device name if there is one, and to their n= ode name # otherwise. (Since 5.2) # +# @x-vcpu-dirty-limit-period: Periodic time (ms) of dirty limit during liv= e migration. +# Defaults to 500ms. (Since 7.1) +# # Features: -# @unstable: Member @x-checkpoint-delay is experimental. +# @unstable: Member @x-checkpoint-delay and @x-vcpu-dirty-limit-period +# are experimental. # # Since: 2.4 ## @@ -795,8 +799,9 @@ 'multifd-channels', 'xbzrle-cache-size', 'max-postcopy-bandwidth', 'max-cpu-throttle', 'multifd-compression', - 'multifd-zlib-level' ,'multifd-zstd-level', - 'block-bitmap-mapping' ] } + 'multifd-zlib-level', 'multifd-zstd-level', + 'block-bitmap-mapping', + { 'name': 'x-vcpu-dirty-limit-period', 'features': ['unstable']= } ] } =20 ## # @MigrateSetParameters: @@ -941,8 +946,12 @@ # block device name if there is one, and to their n= ode name # otherwise. (Since 5.2) # +# @x-vcpu-dirty-limit-period: Periodic time (ms) of dirty limit during liv= e migration. +# Defaults to 500ms. (Since 7.1) +# # Features: -# @unstable: Member @x-checkpoint-delay is experimental. +# @unstable: Member @x-checkpoint-delay and @x-vcpu-dirty-limit-period +# are experimental. # # Since: 2.4 ## @@ -976,7 +985,9 @@ '*multifd-compression': 'MultiFDCompression', '*multifd-zlib-level': 'uint8', '*multifd-zstd-level': 'uint8', - '*block-bitmap-mapping': [ 'BitmapMigrationNodeAlias' ] } } + '*block-bitmap-mapping': [ 'BitmapMigrationNodeAlias' ], + '*x-vcpu-dirty-limit-period': { 'type': 'uint64', + 'features': [ 'unstable' ] } }= } =20 ## # @migrate-set-parameters: @@ -1141,8 +1152,12 @@ # block device name if there is one, and to their n= ode name # otherwise. (Since 5.2) # +# @x-vcpu-dirty-limit-period: Periodic time (ms) of dirty limit during liv= e migration. +# Defaults to 500ms. (Since 7.1) +# # Features: -# @unstable: Member @x-checkpoint-delay is experimental. +# @unstable: Member @x-checkpoint-delay and @x-vcpu-dirty-limit-period +# are experimental. # # Since: 2.4 ## @@ -1174,7 +1189,9 @@ '*multifd-compression': 'MultiFDCompression', '*multifd-zlib-level': 'uint8', '*multifd-zstd-level': 'uint8', - '*block-bitmap-mapping': [ 'BitmapMigrationNodeAlias' ] } } + '*block-bitmap-mapping': [ 'BitmapMigrationNodeAlias' ], + '*x-vcpu-dirty-limit-period': { 'type': 'uint64', + 'features': [ 'unstable' ] } }= } =20 ## # @query-migrate-parameters: --=20 1.8.3.1 From nobody Thu May 16 07:34:32 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1658562850845395.40268945831724; Sat, 23 Jul 2022 00:54:10 -0700 (PDT) Received: from localhost ([::1]:45108 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oF9xg-0004od-Ki for importer@patchew.org; Sat, 23 Jul 2022 03:54:08 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:36850) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1oF9tP-0001Y1-Ty for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:44 -0400 Received: from prt-mail.chinatelecom.cn ([42.123.76.222]:53040 helo=chinatelecom.cn) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oF9tN-0000Pl-3N for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:43 -0400 Received: from clientip-125.69.42.4 (unknown [172.18.0.218]) by chinatelecom.cn (HERMES) with SMTP id E0A332800BD; Sat, 23 Jul 2022 15:49:29 +0800 (CST) Received: from ([172.18.0.218]) by app0025 with ESMTP id 002f8c1861624659bdb326e274126904 for qemu-devel@nongnu.org; Sat, 23 Jul 2022 15:49:32 CST HMM_SOURCE_IP: 172.18.0.218:34686.1353564676 HMM_ATTACHE_NUM: 0000 HMM_SOURCE_TYPE: SMTP X-189-SAVE-TO-SEND: +huangy81@chinatelecom.cn X-Transaction-ID: 002f8c1861624659bdb326e274126904 X-Real-From: huangy81@chinatelecom.cn X-Receive-IP: 172.18.0.218 X-MEDUSA-Status: 0 From: huangy81@chinatelecom.cn To: qemu-devel Cc: Juan Quintela , "Dr. David Alan Gilbert" , Eric Blake , Markus Armbruster , Thomas Huth , Laurent Vivier , Paolo Bonzini , peterx@redhat.com, "Daniel P. Berrange" , =?UTF-8?q?Hyman=20Huang=28=E9=BB=84=E5=8B=87=29?= Subject: [PATCH 2/8] qapi/migration: Introduce vcpu-dirty-limit parameters Date: Sat, 23 Jul 2022 15:49:14 +0800 Message-Id: <01d837637e7725a49d1fd3cd22370d6c9f6b9e61.1658561555.git.huangy81@chinatelecom.cn> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=42.123.76.222; envelope-from=huangy81@chinatelecom.cn; helo=chinatelecom.cn X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZM-MESSAGEID: 1658562854119100001 From: Hyman Huang(=E9=BB=84=E5=8B=87) Introduce "vcpu-dirty-limit" migration parameter used to limit dirty page rate during live migration. "vcpu-dirty-limit" and "x-vcpu-dirty-limit-period" are two dirty-limit-related migration parameters, which can be set before and during live migration by qmp migrate-set-parameters. This two parameters are used to help implement the dirty page rate limit algo of migration. Signed-off-by: Hyman Huang(=E9=BB=84=E5=8B=87) --- migration/migration.c | 14 ++++++++++++++ monitor/hmp-cmds.c | 8 ++++++++ qapi/migration.json | 18 +++++++++++++++--- 3 files changed, 37 insertions(+), 3 deletions(-) diff --git a/migration/migration.c b/migration/migration.c index 7b19f85..ed1a47b 100644 --- a/migration/migration.c +++ b/migration/migration.c @@ -117,6 +117,7 @@ #define DEFAULT_MIGRATE_ANNOUNCE_STEP 100 =20 #define DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD 500 /* ms */ +#define DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT 1 /* MB/s */ =20 static NotifierList migration_state_notifiers =3D NOTIFIER_LIST_INITIALIZER(migration_state_notifiers); @@ -967,6 +968,9 @@ MigrationParameters *qmp_query_migrate_parameters(Error= **errp) params->has_x_vcpu_dirty_limit_period =3D true; params->x_vcpu_dirty_limit_period =3D s->parameters.x_vcpu_dirty_limit= _period; =20 + params->has_vcpu_dirty_limit =3D true; + params->vcpu_dirty_limit =3D s->parameters.vcpu_dirty_limit; + return params; } =20 @@ -1671,6 +1675,10 @@ static void migrate_params_test_apply(MigrateSetPara= meters *params, if (params->has_x_vcpu_dirty_limit_period) { dest->x_vcpu_dirty_limit_period =3D params->x_vcpu_dirty_limit_per= iod; } + + if (params->has_vcpu_dirty_limit) { + dest->vcpu_dirty_limit =3D params->vcpu_dirty_limit; + } } =20 static void migrate_params_apply(MigrateSetParameters *params, Error **err= p) @@ -1797,6 +1805,9 @@ static void migrate_params_apply(MigrateSetParameters= *params, Error **errp) s->parameters.x_vcpu_dirty_limit_period =3D params->x_vcpu_dirty_limit_period; } + if (params->has_vcpu_dirty_limit) { + s->parameters.vcpu_dirty_limit =3D params->vcpu_dirty_limit; + } } =20 void qmp_migrate_set_parameters(MigrateSetParameters *params, Error **errp) @@ -4400,6 +4411,9 @@ static Property migration_properties[] =3D { DEFINE_PROP_UINT64("x-vcpu-dirty-limit-period", MigrationState, parameters.x_vcpu_dirty_limit_period, DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT_PERIOD), + DEFINE_PROP_UINT64("vcpu-dirty-limit", MigrationState, + parameters.vcpu_dirty_limit, + DEFAULT_MIGRATE_VCPU_DIRTY_LIMIT), =20 /* Migration capabilities */ DEFINE_PROP_MIG_CAP("x-xbzrle", MIGRATION_CAPABILITY_XBZRLE), diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c index 64c996c..acbc5e8 100644 --- a/monitor/hmp-cmds.c +++ b/monitor/hmp-cmds.c @@ -536,6 +536,10 @@ void hmp_info_migrate_parameters(Monitor *mon, const Q= Dict *qdict) monitor_printf(mon, "%s: %" PRIu64 " ms\n", MigrationParameter_str(MIGRATION_PARAMETER_X_VCPU_DIRTY_LIMIT_PERI= OD), params->x_vcpu_dirty_limit_period); + + monitor_printf(mon, "%s: %" PRIu64 " MB/s\n", + MigrationParameter_str(MIGRATION_PARAMETER_VCPU_DIRTY_LIMIT), + params->vcpu_dirty_limit); } =20 qapi_free_MigrationParameters(params); @@ -1359,6 +1363,10 @@ void hmp_migrate_set_parameter(Monitor *mon, const Q= Dict *qdict) p->has_x_vcpu_dirty_limit_period =3D true; visit_type_size(v, param, &p->x_vcpu_dirty_limit_period, &err); break; + case MIGRATION_PARAMETER_VCPU_DIRTY_LIMIT: + p->has_vcpu_dirty_limit =3D true; + visit_type_size(v, param, &p->vcpu_dirty_limit, &err); + break; default: assert(0); } diff --git a/qapi/migration.json b/qapi/migration.json index 332c087..0963bab 100644 --- a/qapi/migration.json +++ b/qapi/migration.json @@ -779,6 +779,9 @@ # @x-vcpu-dirty-limit-period: Periodic time (ms) of dirty limit during liv= e migration. # Defaults to 500ms. (Since 7.1) # +# @vcpu-dirty-limit: Dirtyrate limit (MB/s) during live migration. +# Defaults to 1. (Since 7.1) +# # Features: # @unstable: Member @x-checkpoint-delay and @x-vcpu-dirty-limit-period # are experimental. @@ -801,7 +804,8 @@ 'max-cpu-throttle', 'multifd-compression', 'multifd-zlib-level', 'multifd-zstd-level', 'block-bitmap-mapping', - { 'name': 'x-vcpu-dirty-limit-period', 'features': ['unstable']= } ] } + { 'name': 'x-vcpu-dirty-limit-period', 'features': ['unstable']= }, + 'vcpu-dirty-limit'] } =20 ## # @MigrateSetParameters: @@ -949,6 +953,9 @@ # @x-vcpu-dirty-limit-period: Periodic time (ms) of dirty limit during liv= e migration. # Defaults to 500ms. (Since 7.1) # +# @vcpu-dirty-limit: Dirtyrate limit (MB/s) during live migration. +# Defaults to 1. (Since 7.1) +# # Features: # @unstable: Member @x-checkpoint-delay and @x-vcpu-dirty-limit-period # are experimental. @@ -987,7 +994,8 @@ '*multifd-zstd-level': 'uint8', '*block-bitmap-mapping': [ 'BitmapMigrationNodeAlias' ], '*x-vcpu-dirty-limit-period': { 'type': 'uint64', - 'features': [ 'unstable' ] } }= } + 'features': [ 'unstable' ] }, + '*vcpu-dirty-limit': 'uint64'} } =20 ## # @migrate-set-parameters: @@ -1155,6 +1163,9 @@ # @x-vcpu-dirty-limit-period: Periodic time (ms) of dirty limit during liv= e migration. # Defaults to 500ms. (Since 7.1) # +# @vcpu-dirty-limit: Dirtyrate limit (MB/s) during live migration. +# Defaults to 1. (Since 7.1) +# # Features: # @unstable: Member @x-checkpoint-delay and @x-vcpu-dirty-limit-period # are experimental. @@ -1191,7 +1202,8 @@ '*multifd-zstd-level': 'uint8', '*block-bitmap-mapping': [ 'BitmapMigrationNodeAlias' ], '*x-vcpu-dirty-limit-period': { 'type': 'uint64', - 'features': [ 'unstable' ] } }= } + 'features': [ 'unstable' ] }, + '*vcpu-dirty-limit': 'uint64'} } =20 ## # @query-migrate-parameters: --=20 1.8.3.1 From nobody Thu May 16 07:34:32 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 16585635810791020.6869590111546; Sat, 23 Jul 2022 01:06:21 -0700 (PDT) Received: from localhost ([::1]:58416 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oFA9T-0005qv-Ph for importer@patchew.org; Sat, 23 Jul 2022 04:06:19 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:36882) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1oF9tT-0001YJ-SV for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:49 -0400 Received: from prt-mail.chinatelecom.cn ([42.123.76.222]:53114 helo=chinatelecom.cn) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oF9tN-0000Pn-OU for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:45 -0400 Received: from clientip-125.69.42.4 (unknown [172.18.0.218]) by chinatelecom.cn (HERMES) with SMTP id D3F6D2800BE; Sat, 23 Jul 2022 15:49:33 +0800 (CST) Received: from ([172.18.0.218]) by app0025 with ESMTP id 57683ab35c8448a9848f1a03cd4f88ec for qemu-devel@nongnu.org; Sat, 23 Jul 2022 15:49:35 CST HMM_SOURCE_IP: 172.18.0.218:34686.1353564676 HMM_ATTACHE_NUM: 0000 HMM_SOURCE_TYPE: SMTP X-189-SAVE-TO-SEND: +huangy81@chinatelecom.cn X-Transaction-ID: 57683ab35c8448a9848f1a03cd4f88ec X-Real-From: huangy81@chinatelecom.cn X-Receive-IP: 172.18.0.218 X-MEDUSA-Status: 0 From: huangy81@chinatelecom.cn To: qemu-devel Cc: Juan Quintela , "Dr. David Alan Gilbert" , Eric Blake , Markus Armbruster , Thomas Huth , Laurent Vivier , Paolo Bonzini , peterx@redhat.com, "Daniel P. Berrange" , =?UTF-8?q?Hyman=20Huang=28=E9=BB=84=E5=8B=87=29?= Subject: [PATCH 3/8] migration: Introduce dirty-limit capability Date: Sat, 23 Jul 2022 15:49:15 +0800 Message-Id: X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=42.123.76.222; envelope-from=huangy81@chinatelecom.cn; helo=chinatelecom.cn X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZM-MESSAGEID: 1658563581632100001 From: Hyman Huang(=E9=BB=84=E5=8B=87) Introduce migration dirty-limit capability, which can be turned on before live migration and limit dirty page rate durty live migration. Introduce migrate_dirty_limit function to help check if dirty-limit capability enabled during live migration. Meanwhile, refactor vcpu_dirty_rate_stat_collect so that period can be configured instead of hardcoded. dirty-limit capability is kind of like auto-converge but using dirty limit instead of traditional cpu-throttle to throttle guest down. To enable this feature, turn on the dirty-limit capability before live migration using migratioin-set-capabilities, and set the parameters "x-vcpu-dirty-limit-period", "vcpu-dirty-limit" suitably to speed up convergence. Signed-off-by: Hyman Huang(=E9=BB=84=E5=8B=87) --- migration/migration.c | 10 ++++++++++ migration/migration.h | 1 + qapi/migration.json | 4 +++- softmmu/dirtylimit.c | 11 ++++++++++- 4 files changed, 24 insertions(+), 2 deletions(-) diff --git a/migration/migration.c b/migration/migration.c index ed1a47b..84b592e 100644 --- a/migration/migration.c +++ b/migration/migration.c @@ -2508,6 +2508,15 @@ bool migrate_auto_converge(void) return s->enabled_capabilities[MIGRATION_CAPABILITY_AUTO_CONVERGE]; } =20 +bool migrate_dirty_limit(void) +{ + MigrationState *s; + + s =3D migrate_get_current(); + + return s->enabled_capabilities[MIGRATION_CAPABILITY_DIRTY_LIMIT]; +} + bool migrate_zero_blocks(void) { MigrationState *s; @@ -4436,6 +4445,7 @@ static Property migration_properties[] =3D { DEFINE_PROP_MIG_CAP("x-zero-copy-send", MIGRATION_CAPABILITY_ZERO_COPY_SEND), #endif + DEFINE_PROP_MIG_CAP("x-dirty-limit", MIGRATION_CAPABILITY_DIRTY_LIMIT), =20 DEFINE_PROP_END_OF_LIST(), }; diff --git a/migration/migration.h b/migration/migration.h index cdad8ac..7fbb9f8 100644 --- a/migration/migration.h +++ b/migration/migration.h @@ -409,6 +409,7 @@ bool migrate_ignore_shared(void); bool migrate_validate_uuid(void); =20 bool migrate_auto_converge(void); +bool migrate_dirty_limit(void); bool migrate_use_multifd(void); bool migrate_pause_before_switchover(void); int migrate_multifd_channels(void); diff --git a/qapi/migration.json b/qapi/migration.json index 0963bab..39e5f5e 100644 --- a/qapi/migration.json +++ b/qapi/migration.json @@ -477,6 +477,8 @@ # will be handled faster. This is a performance featur= e and # should not affect the correctness of postcopy migrati= on. # (since 7.1) +# @dirty-limit: Use dirty-limit to throttle down guest if enabled. +# (since 7.1) # # Features: # @unstable: Members @x-colo and @x-ignore-shared are experimental. @@ -492,7 +494,7 @@ 'dirty-bitmaps', 'postcopy-blocktime', 'late-block-activate', { 'name': 'x-ignore-shared', 'features': [ 'unstable' ] }, 'validate-uuid', 'background-snapshot', - 'zero-copy-send', 'postcopy-preempt'] } + 'zero-copy-send', 'postcopy-preempt', 'dirty-limit'] } =20 ## # @MigrationCapabilityStatus: diff --git a/softmmu/dirtylimit.c b/softmmu/dirtylimit.c index 8d98cb7..1fdd8c6 100644 --- a/softmmu/dirtylimit.c +++ b/softmmu/dirtylimit.c @@ -23,6 +23,8 @@ #include "exec/memory.h" #include "hw/boards.h" #include "sysemu/kvm.h" +#include "migration/misc.h" +#include "migration/migration.h" #include "trace.h" =20 /* @@ -75,11 +77,18 @@ static bool dirtylimit_quit; =20 static void vcpu_dirty_rate_stat_collect(void) { + MigrationState *s =3D migrate_get_current(); VcpuStat stat; int i =3D 0; + int64_t period =3D DIRTYLIMIT_CALC_TIME_MS; + + if (migrate_dirty_limit() && + migration_is_active(s)) { + period =3D s->parameters.x_vcpu_dirty_limit_period; + } =20 /* calculate vcpu dirtyrate */ - vcpu_calculate_dirtyrate(DIRTYLIMIT_CALC_TIME_MS, + vcpu_calculate_dirtyrate(period, &stat, GLOBAL_DIRTY_LIMIT, false); --=20 1.8.3.1 From nobody Thu May 16 07:34:32 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1658563081257237.3820615747503; Sat, 23 Jul 2022 00:58:01 -0700 (PDT) Received: from localhost ([::1]:51148 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oFA1Q-0000eF-2x for importer@patchew.org; Sat, 23 Jul 2022 03:58:00 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:36880) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1oF9tT-0001YI-Sp for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:49 -0400 Received: from prt-mail.chinatelecom.cn ([42.123.76.222]:53319 helo=chinatelecom.cn) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oF9tN-0000QA-Ey for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:45 -0400 Received: from clientip-125.69.42.4 (unknown [172.18.0.218]) by chinatelecom.cn (HERMES) with SMTP id CFA682800C0; Sat, 23 Jul 2022 15:49:36 +0800 (CST) Received: from ([172.18.0.218]) by app0025 with ESMTP id 84bcf62c3eb04ff5a2bbdc7a1906b26d for qemu-devel@nongnu.org; Sat, 23 Jul 2022 15:49:38 CST HMM_SOURCE_IP: 172.18.0.218:34686.1353564676 HMM_ATTACHE_NUM: 0000 HMM_SOURCE_TYPE: SMTP X-189-SAVE-TO-SEND: +huangy81@chinatelecom.cn X-Transaction-ID: 84bcf62c3eb04ff5a2bbdc7a1906b26d X-Real-From: huangy81@chinatelecom.cn X-Receive-IP: 172.18.0.218 X-MEDUSA-Status: 0 From: huangy81@chinatelecom.cn To: qemu-devel Cc: Juan Quintela , "Dr. David Alan Gilbert" , Eric Blake , Markus Armbruster , Thomas Huth , Laurent Vivier , Paolo Bonzini , peterx@redhat.com, "Daniel P. Berrange" , =?UTF-8?q?Hyman=20Huang=28=E9=BB=84=E5=8B=87=29?= Subject: [PATCH 4/8] migration: Implement dirty-limit convergence algo Date: Sat, 23 Jul 2022 15:49:16 +0800 Message-Id: X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=42.123.76.222; envelope-from=huangy81@chinatelecom.cn; helo=chinatelecom.cn X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZM-MESSAGEID: 1658563083009100001 From: Hyman Huang(=E9=BB=84=E5=8B=87) Implement dirty-limit convergence algo for live migration, which is kind of like auto-converge algo but using dirty-limit instead of cpu throttle to make migration convergent. Signed-off-by: Hyman Huang(=E9=BB=84=E5=8B=87) --- migration/ram.c | 53 +++++++++++++++++++++++++++++++++++++---------= ---- migration/trace-events | 1 + 2 files changed, 41 insertions(+), 13 deletions(-) diff --git a/migration/ram.c b/migration/ram.c index b94669b..2a5cd23 100644 --- a/migration/ram.c +++ b/migration/ram.c @@ -45,6 +45,7 @@ #include "qapi/error.h" #include "qapi/qapi-types-migration.h" #include "qapi/qapi-events-migration.h" +#include "qapi/qapi-commands-migration.h" #include "qapi/qmp/qerror.h" #include "trace.h" #include "exec/ram_addr.h" @@ -57,6 +58,8 @@ #include "qemu/iov.h" #include "multifd.h" #include "sysemu/runstate.h" +#include "sysemu/dirtylimit.h" +#include "sysemu/kvm.h" =20 #include "hw/boards.h" /* for machine_dump_guest_core() */ =20 @@ -1139,6 +1142,21 @@ static void migration_update_rates(RAMState *rs, int= 64_t end_time) } } =20 +/* + * Enable dirty-limit to throttle down the guest + */ +static void migration_dirty_limit_guest(void) +{ + if (!dirtylimit_in_service()) { + MigrationState *s =3D migrate_get_current(); + int64_t quota_dirtyrate =3D s->parameters.vcpu_dirty_limit; + + /* Set quota dirtyrate if dirty limit not in service */ + qmp_set_vcpu_dirty_limit(false, -1, quota_dirtyrate, NULL); + trace_migration_dirty_limit_guest(quota_dirtyrate); + } +} + static void migration_trigger_throttle(RAMState *rs) { MigrationState *s =3D migrate_get_current(); @@ -1148,22 +1166,31 @@ static void migration_trigger_throttle(RAMState *rs) uint64_t bytes_dirty_period =3D rs->num_dirty_pages_period * TARGET_PA= GE_SIZE; uint64_t bytes_dirty_threshold =3D bytes_xfer_period * threshold / 100; =20 - /* During block migration the auto-converge logic incorrectly detects - * that ram migration makes no progress. Avoid this by disabling the - * throttling logic during the bulk phase of block migration. */ - if (migrate_auto_converge() && !blk_mig_bulk_active()) { - /* The following detection logic can be refined later. For now: - Check to see if the ratio between dirtied bytes and the approx. - amount of bytes that just got transferred since the last time - we were in this routine reaches the threshold. If that happens - twice, start or increase throttling. */ - - if ((bytes_dirty_period > bytes_dirty_threshold) && - (++rs->dirty_rate_high_cnt >=3D 2)) { + /* + * The following detection logic can be refined later. For now: + * Check to see if the ratio between dirtied bytes and the approx. + * amount of bytes that just got transferred since the last time + * we were in this routine reaches the threshold. If that happens + * twice, start or increase throttling. + */ + + if ((bytes_dirty_period > bytes_dirty_threshold) && + (++rs->dirty_rate_high_cnt >=3D 2)) { + rs->dirty_rate_high_cnt =3D 0; + /* + * During block migration the auto-converge logic incorrectly dete= cts + * that ram migration makes no progress. Avoid this by disabling t= he + * throttling logic during the bulk phase of block migration + */ + + if (migrate_auto_converge() && !blk_mig_bulk_active()) { trace_migration_throttle(); - rs->dirty_rate_high_cnt =3D 0; mig_throttle_guest_down(bytes_dirty_period, bytes_dirty_threshold); + } else if (migrate_dirty_limit() && + kvm_dirty_ring_enabled() && + migration_is_active(s)) { + migration_dirty_limit_guest(); } } } diff --git a/migration/trace-events b/migration/trace-events index a34afe7..3eb4b0d 100644 --- a/migration/trace-events +++ b/migration/trace-events @@ -89,6 +89,7 @@ migration_bitmap_sync_start(void) "" migration_bitmap_sync_end(uint64_t dirty_pages) "dirty_pages %" PRIu64 migration_bitmap_clear_dirty(char *str, uint64_t start, uint64_t size, uns= igned long page) "rb %s start 0x%"PRIx64" size 0x%"PRIx64" page 0x%lx" migration_throttle(void) "" +migration_dirty_limit_guest(int64_t dirtyrate) "guest dirty page rate limi= t %" PRIi64 " MB/s" ram_discard_range(const char *rbname, uint64_t start, size_t len) "%s: sta= rt: %" PRIx64 " %zx" ram_load_loop(const char *rbname, uint64_t addr, int flags, void *host) "%= s: addr: 0x%" PRIx64 " flags: 0x%x host: %p" ram_load_postcopy_loop(int channel, uint64_t addr, int flags) "chan=3D%d a= ddr=3D0x%" PRIx64 " flags=3D0x%x" --=20 1.8.3.1 From nobody Thu May 16 07:34:32 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1658563542423690.2102473379355; Sat, 23 Jul 2022 01:05:42 -0700 (PDT) Received: from localhost ([::1]:57718 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oFA8n-0005L0-2z for importer@patchew.org; Sat, 23 Jul 2022 04:05:37 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:36962) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1oF9ti-0001gg-PG for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:50:02 -0400 Received: from prt-mail.chinatelecom.cn ([42.123.76.222]:53680 helo=chinatelecom.cn) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oF9tT-0000TK-KE for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:50:02 -0400 Received: from clientip-125.69.42.4 (unknown [172.18.0.218]) by chinatelecom.cn (HERMES) with SMTP id AEC362800C3; Sat, 23 Jul 2022 15:49:39 +0800 (CST) Received: from ([172.18.0.218]) by app0025 with ESMTP id 3e3a940d6ca34fe4bc961cf268e1c8b2 for qemu-devel@nongnu.org; Sat, 23 Jul 2022 15:49:41 CST HMM_SOURCE_IP: 172.18.0.218:34686.1353564676 HMM_ATTACHE_NUM: 0000 HMM_SOURCE_TYPE: SMTP X-189-SAVE-TO-SEND: +huangy81@chinatelecom.cn X-Transaction-ID: 3e3a940d6ca34fe4bc961cf268e1c8b2 X-Real-From: huangy81@chinatelecom.cn X-Receive-IP: 172.18.0.218 X-MEDUSA-Status: 0 From: huangy81@chinatelecom.cn To: qemu-devel Cc: Juan Quintela , "Dr. David Alan Gilbert" , Eric Blake , Markus Armbruster , Thomas Huth , Laurent Vivier , Paolo Bonzini , peterx@redhat.com, "Daniel P. Berrange" , =?UTF-8?q?Hyman=20Huang=28=E9=BB=84=E5=8B=87=29?= Subject: [PATCH 5/8] migration: Export dirty-limit time info Date: Sat, 23 Jul 2022 15:49:17 +0800 Message-Id: X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=42.123.76.222; envelope-from=huangy81@chinatelecom.cn; helo=chinatelecom.cn X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZM-MESSAGEID: 1658563544343100001 From: Hyman Huang(=E9=BB=84=E5=8B=87) Export dirty limit throttle time and estimated ring full time, through which we can observe the process of dirty limit during live migration. Signed-off-by: Hyman Huang(=E9=BB=84=E5=8B=87) --- include/sysemu/dirtylimit.h | 2 ++ migration/migration.c | 10 ++++++++++ monitor/hmp-cmds.c | 10 ++++++++++ qapi/migration.json | 10 +++++++++- softmmu/dirtylimit.c | 22 ++++++++++++++++++++++ 5 files changed, 53 insertions(+), 1 deletion(-) diff --git a/include/sysemu/dirtylimit.h b/include/sysemu/dirtylimit.h index 8d2c1f3..98cc4a6 100644 --- a/include/sysemu/dirtylimit.h +++ b/include/sysemu/dirtylimit.h @@ -34,4 +34,6 @@ void dirtylimit_set_vcpu(int cpu_index, void dirtylimit_set_all(uint64_t quota, bool enable); void dirtylimit_vcpu_execute(CPUState *cpu); +int64_t dirtylimit_throttle_us_per_full(void); +int64_t dirtylimit_us_ring_full(void); #endif diff --git a/migration/migration.c b/migration/migration.c index 84b592e..81a46e2 100644 --- a/migration/migration.c +++ b/migration/migration.c @@ -61,6 +61,7 @@ #include "sysemu/cpus.h" #include "yank_functions.h" #include "sysemu/qtest.h" +#include "sysemu/dirtylimit.h" =20 #define MAX_THROTTLE (128 << 20) /* Migration transfer speed throttl= ing */ =20 @@ -1109,6 +1110,15 @@ static void populate_ram_info(MigrationInfo *info, M= igrationState *s) info->ram->remaining =3D ram_bytes_remaining(); info->ram->dirty_pages_rate =3D ram_counters.dirty_pages_rate; } + + if (migrate_dirty_limit() && dirtylimit_in_service()) { + info->has_dirty_limit_throttle_us_per_full =3D true; + info->dirty_limit_throttle_us_per_full =3D + dirtylimit_throttle_us_per_full(); + + info->has_dirty_limit_us_ring_full =3D true; + info->dirty_limit_us_ring_full =3D dirtylimit_us_ring_full(); + } } =20 static void populate_disk_info(MigrationInfo *info) diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c index acbc5e8..accc869 100644 --- a/monitor/hmp-cmds.c +++ b/monitor/hmp-cmds.c @@ -358,6 +358,16 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict) info->cpu_throttle_percentage); } =20 + if (info->has_dirty_limit_throttle_us_per_full) { + monitor_printf(mon, "dirty-limit throttle time: %" PRIu64 " us\n", + info->dirty_limit_throttle_us_per_full); + } + + if (info->has_dirty_limit_us_ring_full) { + monitor_printf(mon, "dirty-limit ring full time: %" PRIu64 " us\n", + info->dirty_limit_us_ring_full); + } + if (info->has_postcopy_blocktime) { monitor_printf(mon, "postcopy blocktime: %u\n", info->postcopy_blocktime); diff --git a/qapi/migration.json b/qapi/migration.json index 39e5f5e..6b8283f 100644 --- a/qapi/migration.json +++ b/qapi/migration.json @@ -242,6 +242,12 @@ # Present and non-empty when migration is blocked. # (since 6.0) # +# @dirty-limit-throttle-us-per-full: Throttle time (us) during the period = of +# dirty ring full (since 7.0) +# +# @dirty-limit-us-ring-full: Estimated periodic time (us) of dirty ring fu= ll. +# (since 7.0) +# # Since: 0.14 ## { 'struct': 'MigrationInfo', @@ -259,7 +265,9 @@ '*postcopy-blocktime' : 'uint32', '*postcopy-vcpu-blocktime': ['uint32'], '*compression': 'CompressionStats', - '*socket-address': ['SocketAddress'] } } + '*socket-address': ['SocketAddress'], + '*dirty-limit-throttle-us-per-full': 'int64', + '*dirty-limit-us-ring-full': 'int64'} } =20 ## # @query-migrate: diff --git a/softmmu/dirtylimit.c b/softmmu/dirtylimit.c index 1fdd8c6..1251b27 100644 --- a/softmmu/dirtylimit.c +++ b/softmmu/dirtylimit.c @@ -546,6 +546,28 @@ static struct DirtyLimitInfo *dirtylimit_query_vcpu(in= t cpu_index) return info; } =20 +/* Pick up first vcpu throttle time by default */ +int64_t dirtylimit_throttle_us_per_full(void) +{ + CPUState *cpu =3D first_cpu; + return cpu->throttle_us_per_full; +} + +/* + * Estimate dirty ring full time under current dirty page rate. + * Return -1 if guest doesn't dirty memory. + */ +int64_t dirtylimit_us_ring_full(void) +{ + uint64_t curr_rate =3D vcpu_dirty_rate_get(0); + + if (!curr_rate) { + return -1; + } + + return dirtylimit_dirty_ring_full_time(curr_rate); +} + static struct DirtyLimitInfoList *dirtylimit_query_all(void) { int i, index; --=20 1.8.3.1 From nobody Thu May 16 07:34:32 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1658563936700319.8688154351755; Sat, 23 Jul 2022 01:12:16 -0700 (PDT) Received: from localhost ([::1]:36076 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oFAFD-0001u5-GK for importer@patchew.org; Sat, 23 Jul 2022 04:12:15 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:36918) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1oF9tZ-0001ZG-25 for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:53 -0400 Received: from prt-mail.chinatelecom.cn ([42.123.76.222]:53756 helo=chinatelecom.cn) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oF9tT-0000TS-KI for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:52 -0400 Received: from clientip-125.69.42.4 (unknown [172.18.0.218]) by chinatelecom.cn (HERMES) with SMTP id D333D2800C6; Sat, 23 Jul 2022 15:49:41 +0800 (CST) Received: from ([172.18.0.218]) by app0025 with ESMTP id 20134c4d5d6f487d9e80d85893b6e48a for qemu-devel@nongnu.org; Sat, 23 Jul 2022 15:49:44 CST HMM_SOURCE_IP: 172.18.0.218:34686.1353564676 HMM_ATTACHE_NUM: 0000 HMM_SOURCE_TYPE: SMTP X-189-SAVE-TO-SEND: +huangy81@chinatelecom.cn X-Transaction-ID: 20134c4d5d6f487d9e80d85893b6e48a X-Real-From: huangy81@chinatelecom.cn X-Receive-IP: 172.18.0.218 X-MEDUSA-Status: 0 From: huangy81@chinatelecom.cn To: qemu-devel Cc: Juan Quintela , "Dr. David Alan Gilbert" , Eric Blake , Markus Armbruster , Thomas Huth , Laurent Vivier , Paolo Bonzini , peterx@redhat.com, "Daniel P. Berrange" , =?UTF-8?q?Hyman=20Huang=28=E9=BB=84=E5=8B=87=29?= Subject: [PATCH 6/8] tests: Add migration dirty-limit capability test Date: Sat, 23 Jul 2022 15:49:18 +0800 Message-Id: <30161c250875375c2deb914a2fcdb93eb9cd93da.1658561555.git.huangy81@chinatelecom.cn> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=42.123.76.222; envelope-from=huangy81@chinatelecom.cn; helo=chinatelecom.cn X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZM-MESSAGEID: 1658563937706100001 From: Hyman Huang(=E9=BB=84=E5=8B=87) Add migration dirty-limit capability test if kernel support dirty ring. Migration dirty-limit capability introduce dirty limit capability, two parameters: x-vcpu-dirty-limit-period and vcpu-dirty-limit are introduced to implement the live migration with dirty limit. The test case enable the capability and set the corresponding parameters to test migration. When migration switch to pre-switchover phase, like the auto-converge, checking if migration satisfy the convergence condition. Signed-off-by: Hyman Huang(=E9=BB=84=E5=8B=87) --- tests/qtest/migration-test.c | 92 ++++++++++++++++++++++++++++++++++++++++= ++++ 1 file changed, 92 insertions(+) diff --git a/tests/qtest/migration-test.c b/tests/qtest/migration-test.c index 71595a7..88503a1 100644 --- a/tests/qtest/migration-test.c +++ b/tests/qtest/migration-test.c @@ -2412,6 +2412,96 @@ static void test_vcpu_dirty_limit(void) dirtylimit_stop_vm(vm); } =20 +static void test_migrate_dirty_limit(void) +{ + g_autofree char *uri =3D g_strdup_printf("unix:%s/migsocket", tmpfs); + QTestState *from, *to; + int64_t remaining, throttle_us_per_full; + /* + * We want the test to be stable and as fast as possible. + * E.g., with 1Gb/s bandwith migration may pass without dirty limit, + * so we need to decrease a bandwidth. + */ + const int64_t dirtylimit_period =3D 1000, dirtylimit_value =3D 50; + const int64_t max_bandwidth =3D 400000000; /* ~400Mb/s */ + const int64_t downtime_limit =3D 250; /* 250ms */ + /* + * We migrate through unix-socket (> 500Mb/s). + * Thus, expected migration speed ~=3D bandwidth limit (< 500Mb/s). + * So, we can predict expected_threshold + */ + const int64_t expected_threshold =3D max_bandwidth * downtime_limit / = 1000; + MigrateCommon args =3D { + .start =3D { + .use_dirty_ring =3D true, + }, + .listen_uri =3D uri, + .connect_uri =3D uri, + }; + + if (test_migrate_start(&from, &to, args.listen_uri, &args.start)) { + return; + } + + migrate_set_capability(from, "dirty-limit", true); + migrate_set_parameter_int(from, "x-vcpu-dirty-limit-period", + dirtylimit_period); + migrate_set_parameter_int(from, "vcpu-dirty-limit", dirtylimit_value); + + /* + * Set the initial parameters so that the migration could not converge + * without dirty limit. + */ + migrate_set_parameter_int(from, "downtime-limit", 1); + migrate_set_parameter_int(from, "max-bandwidth", 100000000); /* ~100Mb= /s */ + + /* To check limit rate after precopy */ + migrate_set_capability(from, "pause-before-switchover", true); + + /* Wait for the first serial output from the source */ + wait_for_serial("src_serial"); + + migrate_qmp(from, uri, "{}"); + + /* Wait for dirty limit begins */ + throttle_us_per_full =3D 0; + while (throttle_us_per_full =3D=3D 0) { + throttle_us_per_full =3D + read_migrate_property_int(from, "dirty-limit-throttle-us-per-f= ull"); + usleep(100); + g_assert_false(got_stop); + } + + /* + * The dirty limit rate should equals the return value of + * query-vcpu-dirty-limit if dirty limit cap set + */ + g_assert_cmpint(dirtylimit_value, =3D=3D, get_limit_rate(from)); + + /* Now, when we tested if dirty limit works, let it converge */ + migrate_set_parameter_int(from, "downtime-limit", downtime_limit); + migrate_set_parameter_int(from, "max-bandwidth", max_bandwidth); + + /* + * Wait for pre-switchover status to check if migration + * satisfy the convergence condition + */ + wait_for_migration_status(from, "pre-switchover", NULL); + + remaining =3D read_ram_property_int(from, "remaining"); + g_assert_cmpint(remaining, <, + (expected_threshold + expected_threshold / 100)); + + migrate_continue(from, "pre-switchover"); + + qtest_qmp_eventwait(to, "RESUME"); + + wait_for_serial("dest_serial"); + wait_for_migration_complete(from); + + test_migrate_end(from, to, true); +} + static bool kvm_dirty_ring_supported(void) { #if defined(__linux__) && defined(HOST_X86_64) @@ -2577,6 +2667,8 @@ int main(int argc, char **argv) test_precopy_unix_dirty_ring); qtest_add_func("/migration/vcpu_dirty_limit", test_vcpu_dirty_limit); + qtest_add_func("/migration/dirty_limit", + test_migrate_dirty_limit); } =20 ret =3D g_test_run(); --=20 1.8.3.1 From nobody Thu May 16 07:34:32 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1658563014031439.45826489591013; Sat, 23 Jul 2022 00:56:54 -0700 (PDT) Received: from localhost ([::1]:48828 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oFA0J-0007Oi-In for importer@patchew.org; Sat, 23 Jul 2022 03:56:51 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:36942) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1oF9ta-0001aR-9i for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:55 -0400 Received: from prt-mail.chinatelecom.cn ([42.123.76.222]:53990 helo=chinatelecom.cn) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oF9tV-0000Y8-3f for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:54 -0400 Received: from clientip-125.69.42.4 (unknown [172.18.0.218]) by chinatelecom.cn (HERMES) with SMTP id D16A42800BB; Sat, 23 Jul 2022 15:49:45 +0800 (CST) Received: from ([172.18.0.218]) by app0025 with ESMTP id 1c3f498501884087a6f0a6b3c24e6ad6 for qemu-devel@nongnu.org; Sat, 23 Jul 2022 15:49:47 CST HMM_SOURCE_IP: 172.18.0.218:34686.1353564676 HMM_ATTACHE_NUM: 0000 HMM_SOURCE_TYPE: SMTP X-189-SAVE-TO-SEND: +huangy81@chinatelecom.cn X-Transaction-ID: 1c3f498501884087a6f0a6b3c24e6ad6 X-Real-From: huangy81@chinatelecom.cn X-Receive-IP: 172.18.0.218 X-MEDUSA-Status: 0 From: huangy81@chinatelecom.cn To: qemu-devel Cc: Juan Quintela , "Dr. David Alan Gilbert" , Eric Blake , Markus Armbruster , Thomas Huth , Laurent Vivier , Paolo Bonzini , peterx@redhat.com, "Daniel P. Berrange" , =?UTF-8?q?Hyman=20Huang=28=E9=BB=84=E5=8B=87=29?= Subject: [PATCH 7/8] tests/migration: Introduce dirty-ring-size option into guestperf Date: Sat, 23 Jul 2022 15:49:19 +0800 Message-Id: <78a4287b5190fd3a355a30908ec3bcf2509a69a1.1658561555.git.huangy81@chinatelecom.cn> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=42.123.76.222; envelope-from=huangy81@chinatelecom.cn; helo=chinatelecom.cn X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZM-MESSAGEID: 1658563015101100001 From: Hyman Huang(=E9=BB=84=E5=8B=87) Guestperf tool does not enable diry ring feature when test migration by default. To support dirty ring migration performance test, introduce dirty-ring-size option into guestperf tools, which ranges in [1024, 65536]. To set dirty ring size with 4096 during migration test: $ ./tests/migration/guestperf.py --dirty-ring-size 4096 xxx Signed-off-by: Hyman Huang(=E9=BB=84=E5=8B=87) --- tests/migration/guestperf/engine.py | 7 ++++++- tests/migration/guestperf/hardware.py | 8 ++++++-- tests/migration/guestperf/shell.py | 7 ++++++- 3 files changed, 18 insertions(+), 4 deletions(-) diff --git a/tests/migration/guestperf/engine.py b/tests/migration/guestper= f/engine.py index 87a6ab2..2b98f00 100644 --- a/tests/migration/guestperf/engine.py +++ b/tests/migration/guestperf/engine.py @@ -304,7 +304,6 @@ def _get_common_args(self, hardware, tunnelled=3DFalse): cmdline =3D "'" + cmdline + "'" =20 argv =3D [ - "-accel", "kvm", "-cpu", "host", "-kernel", self._kernel, "-initrd", self._initrd, @@ -315,6 +314,12 @@ def _get_common_args(self, hardware, tunnelled=3DFalse= ): "-smp", str(hardware._cpus), ] =20 + if hardware._dirty_ring_size: + argv.extend(["-accel", "kvm,dirty-ring-size=3D%s" % + hardware._dirty_ring_size]) + else: + argv.extend(["-accel", "kvm"]) + if self._debug: argv.extend(["-device", "sga"]) =20 diff --git a/tests/migration/guestperf/hardware.py b/tests/migration/guestp= erf/hardware.py index 3145785..f779cc0 100644 --- a/tests/migration/guestperf/hardware.py +++ b/tests/migration/guestperf/hardware.py @@ -23,7 +23,8 @@ def __init__(self, cpus=3D1, mem=3D1, src_cpu_bind=3DNone, src_mem_bind=3DNone, dst_cpu_bind=3DNone, dst_mem_bind=3DNone, prealloc_pages =3D False, - huge_pages=3DFalse, locked_pages=3DFalse): + huge_pages=3DFalse, locked_pages=3DFalse, + dirty_ring_size=3D0): self._cpus =3D cpus self._mem =3D mem # GiB self._src_mem_bind =3D src_mem_bind # List of NUMA nodes @@ -33,6 +34,7 @@ def __init__(self, cpus=3D1, mem=3D1, self._prealloc_pages =3D prealloc_pages self._huge_pages =3D huge_pages self._locked_pages =3D locked_pages + self._dirty_ring_size =3D dirty_ring_size =20 =20 def serialize(self): @@ -46,6 +48,7 @@ def serialize(self): "prealloc_pages": self._prealloc_pages, "huge_pages": self._huge_pages, "locked_pages": self._locked_pages, + "dirty_ring_size": self._dirty_ring_size, } =20 @classmethod @@ -59,4 +62,5 @@ def deserialize(cls, data): data["dst_mem_bind"], data["prealloc_pages"], data["huge_pages"], - data["locked_pages"]) + data["locked_pages"], + data["dirty_ring_size"]) diff --git a/tests/migration/guestperf/shell.py b/tests/migration/guestperf= /shell.py index 8a809e3..559616f 100644 --- a/tests/migration/guestperf/shell.py +++ b/tests/migration/guestperf/shell.py @@ -60,6 +60,8 @@ def __init__(self): parser.add_argument("--prealloc-pages", dest=3D"prealloc_pages", d= efault=3DFalse) parser.add_argument("--huge-pages", dest=3D"huge_pages", default= =3DFalse) parser.add_argument("--locked-pages", dest=3D"locked_pages", defau= lt=3DFalse) + parser.add_argument("--dirty-ring-size", dest=3D"dirty_ring_size", + default=3D0, type=3Dint) =20 self._parser =3D parser =20 @@ -89,7 +91,10 @@ def split_map(value): =20 locked_pages=3Dargs.locked_pages, huge_pages=3Dargs.huge_pages, - prealloc_pages=3Dargs.prealloc_pages) + prealloc_pages=3Dargs.prealloc_pages, + + dirty_ring_size=3Dargs.dirty_ring_size) + =20 =20 class Shell(BaseShell): --=20 1.8.3.1 From nobody Thu May 16 07:34:32 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1658564051071995.1482447369918; Sat, 23 Jul 2022 01:14:11 -0700 (PDT) Received: from localhost ([::1]:40102 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oFAH4-0004d5-2p for importer@patchew.org; Sat, 23 Jul 2022 04:14:10 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:36946) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1oF9ta-0001aS-MI for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:55 -0400 Received: from prt-mail.chinatelecom.cn ([42.123.76.222]:54189 helo=chinatelecom.cn) by eggs.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1oF9tY-0000bU-4I for qemu-devel@nongnu.org; Sat, 23 Jul 2022 03:49:54 -0400 Received: from clientip-125.69.42.4 (unknown [172.18.0.218]) by chinatelecom.cn (HERMES) with SMTP id CC1032800C9; Sat, 23 Jul 2022 15:49:48 +0800 (CST) Received: from ([172.18.0.218]) by app0025 with ESMTP id 3ea228b10f1549b391711a020a639afa for qemu-devel@nongnu.org; Sat, 23 Jul 2022 15:49:50 CST HMM_SOURCE_IP: 172.18.0.218:34686.1353564676 HMM_ATTACHE_NUM: 0000 HMM_SOURCE_TYPE: SMTP X-189-SAVE-TO-SEND: +huangy81@chinatelecom.cn X-Transaction-ID: 3ea228b10f1549b391711a020a639afa X-Real-From: huangy81@chinatelecom.cn X-Receive-IP: 172.18.0.218 X-MEDUSA-Status: 0 From: huangy81@chinatelecom.cn To: qemu-devel Cc: Juan Quintela , "Dr. David Alan Gilbert" , Eric Blake , Markus Armbruster , Thomas Huth , Laurent Vivier , Paolo Bonzini , peterx@redhat.com, "Daniel P. Berrange" , =?UTF-8?q?Hyman=20Huang=28=E9=BB=84=E5=8B=87=29?= Subject: [PATCH 8/8] tests/migration: Introduce dirty-limit into guestperf Date: Sat, 23 Jul 2022 15:49:20 +0800 Message-Id: <553579e699d070fe3e6ab4b9fb837c90f8308c13.1658561555.git.huangy81@chinatelecom.cn> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=42.123.76.222; envelope-from=huangy81@chinatelecom.cn; helo=chinatelecom.cn X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZM-MESSAGEID: 1658564052064100001 From: Hyman Huang(=E9=BB=84=E5=8B=87) Guestperf tool does not cover the dirty-limit migration currently, support this feature. To enable dirty-limit, setting x-vcpu-dirty-limit-period as 500ms and vcpu-dirty-limit as 10MB/s: $ ./tests/migration/guestperf.py \ --dirty-limit --x-vcpu-dirty-limit-period 500 \ --dirty-limit --vcpu-dirty-limit 10 \ --output output.json To run the entire standardized set of dirty-limit-enabled comparisons, with unix migration: $ ./tests/migration/guestperf-batch.py \ --dst-host localhost --transport unix \ --filter compr-dirty-limit-period* --output outputdir Signed-off-by: Hyman Huang(=E9=BB=84=E5=8B=87) --- tests/migration/guestperf/comparison.py | 14 ++++++++++++++ tests/migration/guestperf/engine.py | 26 ++++++++++++++++++++++++++ tests/migration/guestperf/progress.py | 17 +++++++++++++++-- tests/migration/guestperf/scenario.py | 11 ++++++++++- tests/migration/guestperf/shell.py | 18 +++++++++++++++++- 5 files changed, 82 insertions(+), 4 deletions(-) diff --git a/tests/migration/guestperf/comparison.py b/tests/migration/gues= tperf/comparison.py index c03b3f6..ccc0db9 100644 --- a/tests/migration/guestperf/comparison.py +++ b/tests/migration/guestperf/comparison.py @@ -135,4 +135,18 @@ def __init__(self, name, scenarios): Scenario("compr-multifd-channels-64", multifd=3DTrue, multifd_channels=3D64), ]), + + + # Looking at effect of dirty-limit with + # varying x_vcpu_dirty_limit_period + Comparison("compr-dirty-limit", scenarios =3D [ + Scenario("compr-dirty-limit-period-100", + dirty_limit=3DTrue, x_vcpu_dirty_limit_period=3D100), + Scenario("compr-dirty-limit-period-500", + dirty_limit=3DTrue, x_vcpu_dirty_limit_period=3D500), + Scenario("compr-dirty-limit-period-1000", + dirty_limit=3DTrue, x_vcpu_dirty_limit_period=3D1000), + ]), + + ] diff --git a/tests/migration/guestperf/engine.py b/tests/migration/guestper= f/engine.py index 2b98f00..2f29471 100644 --- a/tests/migration/guestperf/engine.py +++ b/tests/migration/guestperf/engine.py @@ -103,6 +103,8 @@ def _migrate_progress(self, vm): info.get("expected-downtime", 0), info.get("setup-time", 0), info.get("cpu-throttle-percentage", 0), + info.get("dirty-limit-throttle-us-per-full", 0), + info.get("dirty-limit-us-ring-full", 0), ) =20 def _migrate(self, hardware, scenario, src, dst, connect_uri): @@ -204,6 +206,30 @@ def _migrate(self, hardware, scenario, src, dst, conne= ct_uri): resp =3D dst.command("migrate-set-parameters", multifd_channels=3Dscenario._multifd_channe= ls) =20 + if scenario._dirty_limit: + if not hardware._dirty_ring_size: + raise Exception("dirty ring size must be configured when " + "testing dirty limit migration") + + resp =3D src.command("migrate-set-capabilities", + capabilities =3D [ + { "capability": "dirty-limit", + "state": True } + ]) + resp =3D src.command("migrate-set-parameters", + x_vcpu_dirty_limit_period=3Dscenario._x_vcpu_dirty_limit_p= eriod) + resp =3D src.command("migrate-set-parameters", + vcpu_dirty_limit=3Dscenario._vcpu_dirty_lim= it) + resp =3D dst.command("migrate-set-capabilities", + capabilities =3D [ + { "capability": "dirty-limit", + "state": True } + ]) + resp =3D dst.command("migrate-set-parameters", + x_vcpu_dirty_limit_period=3Dscenario._x_vcpu_dirty_limit_p= eriod) + resp =3D dst.command("migrate-set-parameters", + vcpu_dirty_limit=3Dscenario._vcpu_dirty_lim= it) + resp =3D src.command("migrate", uri=3Dconnect_uri) =20 post_copy =3D False diff --git a/tests/migration/guestperf/progress.py b/tests/migration/guestp= erf/progress.py index ab1ee57..dd5d86b 100644 --- a/tests/migration/guestperf/progress.py +++ b/tests/migration/guestperf/progress.py @@ -81,7 +81,9 @@ def __init__(self, downtime, downtime_expected, setup_time, - throttle_pcent): + throttle_pcent, + dirty_limit_throttle_us_per_full, + dirty_limit_us_ring_full): =20 self._status =3D status self._ram =3D ram @@ -91,6 +93,11 @@ def __init__(self, self._downtime_expected =3D downtime_expected self._setup_time =3D setup_time self._throttle_pcent =3D throttle_pcent + self._dirty_limit_throttle_us_per_full =3D + dirty_limit_throttle_us_per_full + self._dirty_limit_us_ring_full =3D + dirty_limit_us_ring_full + =20 def serialize(self): return { @@ -102,6 +109,10 @@ def serialize(self): "downtime_expected": self._downtime_expected, "setup_time": self._setup_time, "throttle_pcent": self._throttle_pcent, + "dirty_limit_throttle_time_per_full": + self._dirty_limit_throttle_us_per_full, + "dirty_limit_ring_full_time": + self._dirty_limit_us_ring_full, } =20 @classmethod @@ -114,4 +125,6 @@ def deserialize(cls, data): data["downtime"], data["downtime_expected"], data["setup_time"], - data["throttle_pcent"]) + data["throttle_pcent"], + data["dirty_limit_throttle_time_per_full"], + data["dirty_limit_ring_full_time"]) diff --git a/tests/migration/guestperf/scenario.py b/tests/migration/guestp= erf/scenario.py index de70d9b..154c4f5 100644 --- a/tests/migration/guestperf/scenario.py +++ b/tests/migration/guestperf/scenario.py @@ -30,7 +30,9 @@ def __init__(self, name, auto_converge=3DFalse, auto_converge_step=3D10, compression_mt=3DFalse, compression_mt_threads=3D1, compression_xbzrle=3DFalse, compression_xbzrle_cache=3D10, - multifd=3DFalse, multifd_channels=3D2): + multifd=3DFalse, multifd_channels=3D2, + dirty_limit=3DFalse, x_vcpu_dirty_limit_period=3D500, + vcpu_dirty_limit=3D1): =20 self._name =3D name =20 @@ -60,6 +62,10 @@ def __init__(self, name, self._multifd =3D multifd self._multifd_channels =3D multifd_channels =20 + self._dirty_limit =3D dirty_limit + self._x_vcpu_dirty_limit_period =3D x_vcpu_dirty_limit_period + self._vcpu_dirty_limit =3D vcpu_dirty_limit + def serialize(self): return { "name": self._name, @@ -79,6 +85,9 @@ def serialize(self): "compression_xbzrle_cache": self._compression_xbzrle_cache, "multifd": self._multifd, "multifd_channels": self._multifd_channels, + "dirty_limit": self._dirty_limit, + "x_vcpu_dirty_limit_period": self._x_vcpu_dirty_limit_period, + "vcpu_dirty_limit": self._vcpu_dirty_limit, } =20 @classmethod diff --git a/tests/migration/guestperf/shell.py b/tests/migration/guestperf= /shell.py index 559616f..23fe895 100644 --- a/tests/migration/guestperf/shell.py +++ b/tests/migration/guestperf/shell.py @@ -132,6 +132,17 @@ def __init__(self): parser.add_argument("--multifd-channels", dest=3D"multifd_channels= ", default=3D2, type=3Dint) =20 + parser.add_argument("--dirty-limit", dest=3D"dirty_limit", default= =3DFalse, + action=3D"store_true") + + parser.add_argument("--x-vcpu-dirty-limit-period", + dest=3D"x_vcpu_dirty_limit_period", + default=3D500, type=3Dint) + + parser.add_argument("--vcpu-dirty-limit", + dest=3D"vcpu_dirty_limit", + default=3D1, type=3Dint) + def get_scenario(self, args): return Scenario(name=3D"perfreport", downtime=3Dargs.downtime, @@ -155,7 +166,12 @@ def get_scenario(self, args): compression_xbzrle_cache=3Dargs.compression_xbzrle= _cache, =20 multifd=3Dargs.multifd, - multifd_channels=3Dargs.multifd_channels) + multifd_channels=3Dargs.multifd_channels, + + dirty_limit=3Dargs.dirty_limit, + x_vcpu_dirty_limit_period=3D + args.x_vcpu_dirty_limit_period, + vcpu_dirty_limit=3Dargs.vcpu_dirty_limit) =20 def run(self, argv): args =3D self._parser.parse_args(argv) --=20 1.8.3.1