From patchwork Mon Sep 12 19:58:47 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 12974085 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 38A27C6FA83 for ; Mon, 12 Sep 2022 19:58:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229739AbiILT6z (ORCPT ); Mon, 12 Sep 2022 15:58:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53012 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229598AbiILT6x (ORCPT ); Mon, 12 Sep 2022 15:58:53 -0400 Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C6E2E23BEF for ; Mon, 12 Sep 2022 12:58:52 -0700 (PDT) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-33d9f6f4656so84075617b3.21 for ; Mon, 12 Sep 2022 12:58:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date; bh=rlbt5+zNSyDwJNoOthwq8HRUdQMHAZ0EW6FGx99U/n8=; b=Bz7OB3YFKTZgQWPWmYANlkutLNExXD3tybAbDokzeDiYcaOY9ex2pvTy0V5juWbsan J3fxUrYNxB/m/Q/0/5YQfaaE0LDum8BjTN8fC7fbDit/IE9F9/N1NKjHmNFPMD6GZ+Fi rwEuRPJ6I88axKjuGoWbvx406XU77HBFbWpdvLs7mzvBgBdWM4dl74mdiQn4HUDIxcQi BfRVmS1WDb5SQosrW3939GkQ8embA8PCe8CNQXjgQ2zFDkYsSE7FfW/7W6sorIdoVgzF /oX244XKAVc0UmYZS16JWwoK9qgL9fen34WW95JMLXn/Q2TsnpEKOU9wk+S2Y6S0cdY3 5Nzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date; bh=rlbt5+zNSyDwJNoOthwq8HRUdQMHAZ0EW6FGx99U/n8=; b=DLI8XIbkHdfx9qPPpWnU4AXF0XETjANr7iOBPAeAggpvH7wXl4670tNODZKzW1onj4 kEnRBq2UTPH5Oeg3z0n3wp17MI0/5DBu5I43NOUYFrkQRjFKsznfmBqWEYismKUpzwvg nTFJ4+626Yn8D50vJp3qhoTuXInvCY4QVTuk/z+ibouS1BoaCdagKprwMNlmNyjgaBqn FfTkQCjYnpW23nj5Ll4wwoKvH1ANq5P7YZbqh23gpqm9LiDG3gVYakgAVTusssdk9trd /seN7LIBZm9a5OZt5tA4Kd8wkV7E9zMyc+0dCS62GlvGqEGj+qGYJ3vR0vLI+cilvCkw Xnuw== X-Gm-Message-State: ACgBeo21lMGYR46TDGRd+sznN9BId7Z35NTJSLuzE1LyjV87PTPybuQ4 yDccHy8rrAPGt26GOcyYBsJsaB0ExYUGdj1B61EAK5BNHZuDM8JMRSUxJNpQoEBDRJ9r3rBhDZ/ vCdujZtRvBOORdqhUTZeu2yl1ols+xn4E68VX5xiV0gfzwfkZGnx9FIIpmCpQoGFBzaLXjTU= X-Google-Smtp-Source: AA6agR5b2wCh93SCXUI8WLqKnRMP5PLDRaQSL72B4J1WB8fDukA8iR34nhskqhJmSpjZkPJeaXy35+5M1B6psYZbKA== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a0d:de83:0:b0:337:c0bf:12ee with SMTP id h125-20020a0dde83000000b00337c0bf12eemr22507349ywe.289.1663012731964; Mon, 12 Sep 2022 12:58:51 -0700 (PDT) Date: Mon, 12 Sep 2022 19:58:47 +0000 In-Reply-To: <20220912195849.3989707-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20220912195849.3989707-1-coltonlewis@google.com> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog Message-ID: <20220912195849.3989707-2-coltonlewis@google.com> Subject: [PATCH v6 1/3] KVM: selftests: implement random number generation for guest code From: Colton Lewis To: kvm@vger.kernel.org Cc: pbonzini@redhat.com, maz@kernel.org, dmatlack@google.com, seanjc@google.com, oupton@google.com, ricarkol@google.com, andrew.jones@linux.dev, Colton Lewis Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Implement random number generation for guest code to randomize parts of the test, making it less predictable and a more accurate reflection of reality. Create a -r argument to specify a random seed. If no argument is provided, the seed defaults to 0. The random seed is set with perf_test_set_random_seed() and must be set before guest_code runs to apply. The random number generator chosen is the Park-Miller Linear Congruential Generator, a fancy name for a basic and well-understood random number generator entirely sufficient for this purpose. Each vCPU calculates its own seed by adding its index to the seed provided. Signed-off-by: Colton Lewis Reviewed-by: Ricardo Koller --- tools/testing/selftests/kvm/dirty_log_perf_test.c | 12 ++++++++++-- tools/testing/selftests/kvm/include/perf_test_util.h | 2 ++ tools/testing/selftests/kvm/include/test_util.h | 2 ++ tools/testing/selftests/kvm/lib/perf_test_util.c | 8 ++++++++ tools/testing/selftests/kvm/lib/test_util.c | 9 +++++++++ 5 files changed, 31 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/kvm/dirty_log_perf_test.c b/tools/testing/selftests/kvm/dirty_log_perf_test.c index d60a34cdfaee..a89a620f50d4 100644 --- a/tools/testing/selftests/kvm/dirty_log_perf_test.c +++ b/tools/testing/selftests/kvm/dirty_log_perf_test.c @@ -126,6 +126,7 @@ struct test_params { bool partition_vcpu_memory_access; enum vm_mem_backing_src_type backing_src; int slots; + uint32_t random_seed; }; static void toggle_dirty_logging(struct kvm_vm *vm, int slots, bool enable) @@ -220,6 +221,9 @@ static void run_test(enum vm_guest_mode mode, void *arg) p->slots, p->backing_src, p->partition_vcpu_memory_access); + /* If no argument provided, random seed will be 0. */ + pr_info("Random seed: %u\n", p->random_seed); + perf_test_set_random_seed(vm, p->random_seed); perf_test_set_wr_fract(vm, p->wr_fract); guest_num_pages = (nr_vcpus * guest_percpu_mem_size) >> vm_get_page_shift(vm); @@ -337,7 +341,7 @@ static void help(char *name) { puts(""); printf("usage: %s [-h] [-i iterations] [-p offset] [-g] " - "[-m mode] [-n] [-b vcpu bytes] [-v vcpus] [-o] [-s mem type]" + "[-m mode] [-n] [-b vcpu bytes] [-v vcpus] [-o] [-r random seed ] [-s mem type]" "[-x memslots]\n", name); puts(""); printf(" -i: specify iteration counts (default: %"PRIu64")\n", @@ -362,6 +366,7 @@ static void help(char *name) printf(" -v: specify the number of vCPUs to run.\n"); printf(" -o: Overlap guest memory accesses instead of partitioning\n" " them into a separate region of memory for each vCPU.\n"); + printf(" -r: specify the starting random seed.\n"); backing_src_help("-s"); printf(" -x: Split the memory region into this number of memslots.\n" " (default: 1)\n"); @@ -388,7 +393,7 @@ int main(int argc, char *argv[]) guest_modes_append_default(); - while ((opt = getopt(argc, argv, "ghi:p:m:nb:f:v:os:x:")) != -1) { + while ((opt = getopt(argc, argv, "ghi:p:m:nb:f:v:or:s:x:")) != -1) { switch (opt) { case 'g': dirty_log_manual_caps = 0; @@ -421,6 +426,9 @@ int main(int argc, char *argv[]) case 'o': p.partition_vcpu_memory_access = false; break; + case 'r': + p.random_seed = atoi(optarg); + break; case 's': p.backing_src = parse_backing_src_type(optarg); break; diff --git a/tools/testing/selftests/kvm/include/perf_test_util.h b/tools/testing/selftests/kvm/include/perf_test_util.h index d822cb670f1c..f18530984b42 100644 --- a/tools/testing/selftests/kvm/include/perf_test_util.h +++ b/tools/testing/selftests/kvm/include/perf_test_util.h @@ -34,6 +34,7 @@ struct perf_test_args { uint64_t gpa; uint64_t size; uint64_t guest_page_size; + uint32_t random_seed; int wr_fract; /* Run vCPUs in L2 instead of L1, if the architecture supports it. */ @@ -51,6 +52,7 @@ struct kvm_vm *perf_test_create_vm(enum vm_guest_mode mode, int vcpus, void perf_test_destroy_vm(struct kvm_vm *vm); void perf_test_set_wr_fract(struct kvm_vm *vm, int wr_fract); +void perf_test_set_random_seed(struct kvm_vm *vm, uint32_t random_seed); void perf_test_start_vcpu_threads(int vcpus, void (*vcpu_fn)(struct perf_test_vcpu_args *)); void perf_test_join_vcpu_threads(int vcpus); diff --git a/tools/testing/selftests/kvm/include/test_util.h b/tools/testing/selftests/kvm/include/test_util.h index 99e0dcdc923f..2dd286bcf46f 100644 --- a/tools/testing/selftests/kvm/include/test_util.h +++ b/tools/testing/selftests/kvm/include/test_util.h @@ -143,4 +143,6 @@ static inline void *align_ptr_up(void *x, size_t size) return (void *)align_up((unsigned long)x, size); } +void guest_random(uint32_t *seed); + #endif /* SELFTEST_KVM_TEST_UTIL_H */ diff --git a/tools/testing/selftests/kvm/lib/perf_test_util.c b/tools/testing/selftests/kvm/lib/perf_test_util.c index f989ff91f022..b1e731de0966 100644 --- a/tools/testing/selftests/kvm/lib/perf_test_util.c +++ b/tools/testing/selftests/kvm/lib/perf_test_util.c @@ -47,6 +47,7 @@ void perf_test_guest_code(uint32_t vcpu_id) uint64_t gva; uint64_t pages; int i; + uint32_t rand = pta->random_seed + vcpu_id; /* Make sure vCPU args data structure is not corrupt. */ GUEST_ASSERT(vcpu_args->vcpu_id == vcpu_id); @@ -57,6 +58,7 @@ void perf_test_guest_code(uint32_t vcpu_id) while (true) { for (i = 0; i < pages; i++) { uint64_t addr = gva + (i * pta->guest_page_size); + guest_random(&rand); if (i % pta->wr_fract == 0) *(uint64_t *)addr = 0x0123456789ABCDEF; @@ -224,6 +226,12 @@ void perf_test_set_wr_fract(struct kvm_vm *vm, int wr_fract) sync_global_to_guest(vm, perf_test_args); } +void perf_test_set_random_seed(struct kvm_vm *vm, uint32_t random_seed) +{ + perf_test_args.random_seed = random_seed; + sync_global_to_guest(vm, perf_test_args.random_seed); +} + uint64_t __weak perf_test_nested_pages(int nr_vcpus) { return 0; diff --git a/tools/testing/selftests/kvm/lib/test_util.c b/tools/testing/selftests/kvm/lib/test_util.c index 6d23878bbfe1..28c895743abe 100644 --- a/tools/testing/selftests/kvm/lib/test_util.c +++ b/tools/testing/selftests/kvm/lib/test_util.c @@ -17,6 +17,15 @@ #include "test_util.h" +/* + * Random number generator that is usable from guest code. This is the + * Park-Miller LCG using standard constants. + */ +void guest_random(uint32_t *seed) +{ + *seed = (uint64_t)*seed * 48271 % ((uint32_t)(1 << 31) - 1); +} + /* * Parses "[0-9]+[kmgt]?". */ From patchwork Mon Sep 12 19:58:48 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 12974086 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E1E39C6FA82 for ; Mon, 12 Sep 2022 19:58:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229598AbiILT65 (ORCPT ); Mon, 12 Sep 2022 15:58:57 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53040 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229746AbiILT6z (ORCPT ); Mon, 12 Sep 2022 15:58:55 -0400 Received: from mail-yb1-xb4a.google.com (mail-yb1-xb4a.google.com [IPv6:2607:f8b0:4864:20::b4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 087F52B27D for ; Mon, 12 Sep 2022 12:58:54 -0700 (PDT) Received: by mail-yb1-xb4a.google.com with SMTP id b14-20020a056902030e00b006a827d81fd8so8152578ybs.17 for ; Mon, 12 Sep 2022 12:58:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date; bh=ReL31gFVBtM0T5XeVkKbrWlb/S7H+C7/yMtVoeFH/ic=; b=f5/eiddU61a9XS1LBPWHtj3JjjCC1gqQz/hox1wnewJumz0TcZ24E4BZXNrcMUQhXk ppX6DCeSSVHUztJcTk+/IkXvE4GEwEHpaHUKOYhezsvc3SweTYjMMF5rq85bQ5rW0rO2 8lotfzNmbIk0FC2wq9045Y1408Cb+1Ui6CPK0dFNPyIME42maTX53zSKVB+8aNeArvow Noe1QolnXc1EMuLBlL2qC8u1EeEjIrlpWUTy/scgY02nlOdGfTF4+1K7eLpyghHVopQd lFpm3zAS442cLG7TSllxgNjsU52daIZ9q7euk7himgzdud0FEu+iEKrOL2y4SpVIZnlk 96lA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date; bh=ReL31gFVBtM0T5XeVkKbrWlb/S7H+C7/yMtVoeFH/ic=; b=4z/4wYmd0uJ7f548mpmDOZVsTaujBvHNwVc4vjNM+B4XeaaZbLxrA08DbvQQ0J3Fr2 Ce+ysntVbAVQyI4xN+9snIlqZwM8fibs9KSrXeUiaxhu7jdFVcKBGB3wW9dqVs7RZeF7 5swSltQjeezKtwbh+WU21m7K/JgG6qU1gIgTVVG0RZwONefis7taDqVlZJHLo0vEDzyD 4L15TbQAuANyQKP4aG1PJyze3GL8cnuW7XoEvOpxVGgJQ+wgBSNj48XKWAExmnsmHyZP vMXPtrUfuicPzVqahAt5uY58a3bgV+bsa29xCpEwtLjr98CtWMMRm/zL6mF2BnwB9foA K5gw== X-Gm-Message-State: ACgBeo1GDeAal9aznlMKj1k+rkOg7yquaGxx7GXouUxlTR966ezHwpnx 86GBg68R/5N/bhdpTOKPaCcOyiBcdHn7oK0vAIgR88Z69PF2I31IYrfKcckq1lfOr692datsIc9 mHtmd6CBMPxrYLSdgV74CBRPGJLFluyif8nRUhq0pUH3BjO5AhsIKf9sUoWHTJXPRqLsAQnk= X-Google-Smtp-Source: AA6agR5XEafhzfU6qMZ/56wFocEYWnl77fF038uunHPc1OYbYxSpiPPaUlJtCpeTgZCtHo44TFPnCnX6Bg+VpTHisg== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a25:e7c6:0:b0:6ae:62c2:1566 with SMTP id e189-20020a25e7c6000000b006ae62c21566mr16255918ybh.631.1663012733194; Mon, 12 Sep 2022 12:58:53 -0700 (PDT) Date: Mon, 12 Sep 2022 19:58:48 +0000 In-Reply-To: <20220912195849.3989707-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20220912195849.3989707-1-coltonlewis@google.com> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog Message-ID: <20220912195849.3989707-3-coltonlewis@google.com> Subject: [PATCH v6 2/3] KVM: selftests: randomize which pages are written vs read From: Colton Lewis To: kvm@vger.kernel.org Cc: pbonzini@redhat.com, maz@kernel.org, dmatlack@google.com, seanjc@google.com, oupton@google.com, ricarkol@google.com, andrew.jones@linux.dev, Colton Lewis Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Randomize which pages are written vs read using the random number generator. Change the variable wr_fract and associated function calls to write_percent that now operates as a percentage from 0 to 100 where X means each page has an X% chance of being written. Change the -f argument to -w to reflect the new variable semantics. Keep the same default of 100% writes. Population always uses 100% writes to ensure all memory is actually populated and not just mapped to the zero page. The prevents expensive copy-on-write faults from occurring during the dirty memory iterations below, which would pollute the performance results. Signed-off-by: Colton Lewis Reviewed-by: Ricardo Koller Reviewed-by: David Matlack --- .../selftests/kvm/access_tracking_perf_test.c | 2 +- .../selftests/kvm/dirty_log_perf_test.c | 37 ++++++++++++------- .../selftests/kvm/include/perf_test_util.h | 4 +- .../selftests/kvm/lib/perf_test_util.c | 10 ++--- 4 files changed, 32 insertions(+), 21 deletions(-) diff --git a/tools/testing/selftests/kvm/access_tracking_perf_test.c b/tools/testing/selftests/kvm/access_tracking_perf_test.c index d8909032317a..d86046ef3a0b 100644 --- a/tools/testing/selftests/kvm/access_tracking_perf_test.c +++ b/tools/testing/selftests/kvm/access_tracking_perf_test.c @@ -274,7 +274,7 @@ static void run_iteration(struct kvm_vm *vm, int vcpus, const char *description) static void access_memory(struct kvm_vm *vm, int vcpus, enum access_type access, const char *description) { - perf_test_set_wr_fract(vm, (access == ACCESS_READ) ? INT_MAX : 1); + perf_test_set_write_percent(vm, (access == ACCESS_READ) ? 0 : 100); iteration_work = ITERATION_ACCESS_MEMORY; run_iteration(vm, vcpus, description); } diff --git a/tools/testing/selftests/kvm/dirty_log_perf_test.c b/tools/testing/selftests/kvm/dirty_log_perf_test.c index a89a620f50d4..dfa5957332b1 100644 --- a/tools/testing/selftests/kvm/dirty_log_perf_test.c +++ b/tools/testing/selftests/kvm/dirty_log_perf_test.c @@ -122,10 +122,10 @@ static void vcpu_worker(struct perf_test_vcpu_args *vcpu_args) struct test_params { unsigned long iterations; uint64_t phys_offset; - int wr_fract; bool partition_vcpu_memory_access; enum vm_mem_backing_src_type backing_src; int slots; + uint32_t write_percent; uint32_t random_seed; }; @@ -224,7 +224,6 @@ static void run_test(enum vm_guest_mode mode, void *arg) /* If no argument provided, random seed will be 0. */ pr_info("Random seed: %u\n", p->random_seed); perf_test_set_random_seed(vm, p->random_seed); - perf_test_set_wr_fract(vm, p->wr_fract); guest_num_pages = (nr_vcpus * guest_percpu_mem_size) >> vm_get_page_shift(vm); guest_num_pages = vm_adjust_num_guest_pages(mode, guest_num_pages); @@ -249,6 +248,14 @@ static void run_test(enum vm_guest_mode mode, void *arg) for (vcpu_id = 0; vcpu_id < nr_vcpus; vcpu_id++) vcpu_last_completed_iteration[vcpu_id] = -1; + /* + * Use 100% writes during the population phase to ensure all + * memory is actually populated and not just mapped to the zero + * page. The prevents expensive copy-on-write faults from + * occurring during the dirty memory iterations below, which + * would pollute the performance results. + */ + perf_test_set_write_percent(vm, 100); perf_test_start_vcpu_threads(nr_vcpus, vcpu_worker); /* Allow the vCPUs to populate memory */ @@ -270,6 +277,8 @@ static void run_test(enum vm_guest_mode mode, void *arg) pr_info("Enabling dirty logging time: %ld.%.9lds\n\n", ts_diff.tv_sec, ts_diff.tv_nsec); + perf_test_set_write_percent(vm, p->write_percent); + while (iteration < p->iterations) { /* * Incrementing the iteration number will start the vCPUs @@ -342,7 +351,7 @@ static void help(char *name) puts(""); printf("usage: %s [-h] [-i iterations] [-p offset] [-g] " "[-m mode] [-n] [-b vcpu bytes] [-v vcpus] [-o] [-r random seed ] [-s mem type]" - "[-x memslots]\n", name); + "[-x memslots] [-w percentage]\n", name); puts(""); printf(" -i: specify iteration counts (default: %"PRIu64")\n", TEST_HOST_LOOP_N); @@ -359,10 +368,6 @@ static void help(char *name) printf(" -b: specify the size of the memory region which should be\n" " dirtied by each vCPU. e.g. 10M or 3G.\n" " (default: 1G)\n"); - printf(" -f: specify the fraction of pages which should be written to\n" - " as opposed to simply read, in the form\n" - " 1/.\n" - " (default: 1 i.e. all pages are written to.)\n"); printf(" -v: specify the number of vCPUs to run.\n"); printf(" -o: Overlap guest memory accesses instead of partitioning\n" " them into a separate region of memory for each vCPU.\n"); @@ -370,6 +375,11 @@ static void help(char *name) backing_src_help("-s"); printf(" -x: Split the memory region into this number of memslots.\n" " (default: 1)\n"); + printf(" -w: specify the percentage of pages which should be written to\n" + " as an integer from 0-100 inclusive. This is probabalistic,\n" + " so -w X means each page has an X%% chance of writing\n" + " and a (100-X)%% chance of reading.\n" + " (default: 100 i.e. all pages are written to.)\n"); puts(""); exit(0); } @@ -379,10 +389,10 @@ int main(int argc, char *argv[]) int max_vcpus = kvm_check_cap(KVM_CAP_MAX_VCPUS); struct test_params p = { .iterations = TEST_HOST_LOOP_N, - .wr_fract = 1, .partition_vcpu_memory_access = true, .backing_src = DEFAULT_VM_MEM_SRC, .slots = 1, + .write_percent = 100, }; int opt; @@ -393,7 +403,7 @@ int main(int argc, char *argv[]) guest_modes_append_default(); - while ((opt = getopt(argc, argv, "ghi:p:m:nb:f:v:or:s:x:")) != -1) { + while ((opt = getopt(argc, argv, "ghi:p:m:nb:v:or:s:x:w:")) != -1) { switch (opt) { case 'g': dirty_log_manual_caps = 0; @@ -413,10 +423,11 @@ int main(int argc, char *argv[]) case 'b': guest_percpu_mem_size = parse_size(optarg); break; - case 'f': - p.wr_fract = atoi(optarg); - TEST_ASSERT(p.wr_fract >= 1, - "Write fraction cannot be less than one"); + case 'w': + p.write_percent = atoi(optarg); + TEST_ASSERT(p.write_percent >= 0 + && p.write_percent <= 100, + "Write percentage must be between 0 and 100"); break; case 'v': nr_vcpus = atoi(optarg); diff --git a/tools/testing/selftests/kvm/include/perf_test_util.h b/tools/testing/selftests/kvm/include/perf_test_util.h index f18530984b42..f93f2ea7c6a3 100644 --- a/tools/testing/selftests/kvm/include/perf_test_util.h +++ b/tools/testing/selftests/kvm/include/perf_test_util.h @@ -35,7 +35,7 @@ struct perf_test_args { uint64_t size; uint64_t guest_page_size; uint32_t random_seed; - int wr_fract; + uint32_t write_percent; /* Run vCPUs in L2 instead of L1, if the architecture supports it. */ bool nested; @@ -51,7 +51,7 @@ struct kvm_vm *perf_test_create_vm(enum vm_guest_mode mode, int vcpus, bool partition_vcpu_memory_access); void perf_test_destroy_vm(struct kvm_vm *vm); -void perf_test_set_wr_fract(struct kvm_vm *vm, int wr_fract); +void perf_test_set_write_percent(struct kvm_vm *vm, uint32_t write_percent); void perf_test_set_random_seed(struct kvm_vm *vm, uint32_t random_seed); void perf_test_start_vcpu_threads(int vcpus, void (*vcpu_fn)(struct perf_test_vcpu_args *)); diff --git a/tools/testing/selftests/kvm/lib/perf_test_util.c b/tools/testing/selftests/kvm/lib/perf_test_util.c index b1e731de0966..9effd229b75d 100644 --- a/tools/testing/selftests/kvm/lib/perf_test_util.c +++ b/tools/testing/selftests/kvm/lib/perf_test_util.c @@ -60,7 +60,7 @@ void perf_test_guest_code(uint32_t vcpu_id) uint64_t addr = gva + (i * pta->guest_page_size); guest_random(&rand); - if (i % pta->wr_fract == 0) + if (rand % 100 < pta->write_percent) *(uint64_t *)addr = 0x0123456789ABCDEF; else READ_ONCE(*(uint64_t *)addr); @@ -118,7 +118,7 @@ struct kvm_vm *perf_test_create_vm(enum vm_guest_mode mode, int vcpus, pr_info("Testing guest mode: %s\n", vm_guest_mode_string(mode)); /* By default vCPUs will write to memory. */ - pta->wr_fract = 1; + pta->write_percent = 100; /* * Snapshot the non-huge page size. This is used by the guest code to @@ -220,10 +220,10 @@ void perf_test_destroy_vm(struct kvm_vm *vm) kvm_vm_free(vm); } -void perf_test_set_wr_fract(struct kvm_vm *vm, int wr_fract) +void perf_test_set_write_percent(struct kvm_vm *vm, uint32_t write_percent) { - perf_test_args.wr_fract = wr_fract; - sync_global_to_guest(vm, perf_test_args); + perf_test_args.write_percent = write_percent; + sync_global_to_guest(vm, perf_test_args.write_percent); } void perf_test_set_random_seed(struct kvm_vm *vm, uint32_t random_seed) From patchwork Mon Sep 12 19:58:49 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 12974087 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 552AEC6FA83 for ; Mon, 12 Sep 2022 19:58:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229553AbiILT66 (ORCPT ); Mon, 12 Sep 2022 15:58:58 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53050 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229698AbiILT6z (ORCPT ); Mon, 12 Sep 2022 15:58:55 -0400 Received: from mail-io1-xd49.google.com (mail-io1-xd49.google.com [IPv6:2607:f8b0:4864:20::d49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E6F72476D8 for ; Mon, 12 Sep 2022 12:58:54 -0700 (PDT) Received: by mail-io1-xd49.google.com with SMTP id i14-20020a5d934e000000b006892db5bcd4so6194869ioo.22 for ; Mon, 12 Sep 2022 12:58:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date; bh=gxBeRa2VjQQW/muLHdmZltqewhqJks5GzmP5Kl8OFNk=; b=AfM/BHiqIVltm1RG/McIYJ/69vf1yTwL+texDN/60IrqHt48kB5ucZXQ+f7qo6dlhV WyH/HxGN6FXqkdhqt/wn4Bk1imii/eSWbKaunDzTxGKt/09WaOhA94zuQNShj/3CrWRE 2UjNOxtVT1tSyIOPwVYBSi4XnUaL7VUwO/sjQRpbqaQB+9QD4pgDFRlwy6ioEJeFG1f+ CwHCAHtQ8lkwv1PuDDW4SdAO39D8waGYmkwaBocaxfwN7c/2EO7mWtUOoU1Xafj/zMPr NtFGP8IJNdFhLCgp3oEI8Tg09o48PNoUvd2tbR7DVipruPOWcmEYgl9etzqENHhP3u4E AL/Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date; bh=gxBeRa2VjQQW/muLHdmZltqewhqJks5GzmP5Kl8OFNk=; b=umCUpFywOHj6gYOmHsM8kaoDWQD1hQVfbfbP81+ATqdrmlC/psff4397pvx1zuod// rWe5f0AtRyQkHoqohDwdH1m28+1ExAjSgJW6xTMHn5VFoXajJj+qOX2p+wX2yU3e/qNX xq9v0AxGGBTDIRQobpvi/NEJdCppJ2XTMjMhPRRUW50mxpsgmBHQAfhl1dVovB3a2/fj 7cMH5yYybJ8FOassvMpSWXkGQoQTY4rtPEvU24gYIJ3qcqx4iI2velbkMt8+IXcoGmHx Feccp22WXe0v83Zty5P1ttZYwN80WSADt3E/mlWsVoETrT8lrKAQKxbtyOQMvVmJB4tH ZCrw== X-Gm-Message-State: ACgBeo2F+RC0rQyT3wBso6UfFZ+RuJoy5tEAMB08xckJbeaUM3LD1yzn LJQfevFvzBhU6cOrSAv80R/IKQTerH4AmqQRY8yd5P49RKVdgxrpykcPo/Ke9rt1Vubok/DbKQa NmPCoZkJkkFUHGeOs4P8uhPE4jdSvQ+hZvznvLLKVJtv5OGbWTWxD7gigGCAoiaEvCsMs1FM= X-Google-Smtp-Source: AA6agR6iuH1XffI4lsNEcm+QiHZDtLOukN28JbwgZS/L5SiShfvBigS4bKdz0I04WbBh7eIvqzl9PFWIr6uNN52hLw== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a05:6638:2388:b0:34a:e033:396b with SMTP id q8-20020a056638238800b0034ae033396bmr14107350jat.93.1663012734297; Mon, 12 Sep 2022 12:58:54 -0700 (PDT) Date: Mon, 12 Sep 2022 19:58:49 +0000 In-Reply-To: <20220912195849.3989707-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20220912195849.3989707-1-coltonlewis@google.com> X-Mailer: git-send-email 2.37.2.789.g6183377224-goog Message-ID: <20220912195849.3989707-4-coltonlewis@google.com> Subject: [PATCH v6 3/3] KVM: selftests: randomize page access order From: Colton Lewis To: kvm@vger.kernel.org Cc: pbonzini@redhat.com, maz@kernel.org, dmatlack@google.com, seanjc@google.com, oupton@google.com, ricarkol@google.com, andrew.jones@linux.dev, Colton Lewis Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Create the ability to randomize page access order with the -a argument. This includes the possibility that the same pages may be hit multiple times during an iteration or not at all. Population has random access as false to ensure all pages will be touched by population and avoid page faults in late dirty memory that would pollute the test results. Signed-off-by: Colton Lewis Reviewed-by: Ricardo Koller --- .../selftests/kvm/dirty_log_perf_test.c | 11 +++++++++-- .../selftests/kvm/include/perf_test_util.h | 2 ++ .../selftests/kvm/lib/perf_test_util.c | 19 ++++++++++++++++++- 3 files changed, 29 insertions(+), 3 deletions(-) diff --git a/tools/testing/selftests/kvm/dirty_log_perf_test.c b/tools/testing/selftests/kvm/dirty_log_perf_test.c index dfa5957332b1..ccc1f571645a 100644 --- a/tools/testing/selftests/kvm/dirty_log_perf_test.c +++ b/tools/testing/selftests/kvm/dirty_log_perf_test.c @@ -127,6 +127,7 @@ struct test_params { int slots; uint32_t write_percent; uint32_t random_seed; + bool random_access; }; static void toggle_dirty_logging(struct kvm_vm *vm, int slots, bool enable) @@ -256,6 +257,7 @@ static void run_test(enum vm_guest_mode mode, void *arg) * would pollute the performance results. */ perf_test_set_write_percent(vm, 100); + perf_test_set_random_access(vm, false); perf_test_start_vcpu_threads(nr_vcpus, vcpu_worker); /* Allow the vCPUs to populate memory */ @@ -278,6 +280,7 @@ static void run_test(enum vm_guest_mode mode, void *arg) ts_diff.tv_sec, ts_diff.tv_nsec); perf_test_set_write_percent(vm, p->write_percent); + perf_test_set_random_access(vm, p->random_access); while (iteration < p->iterations) { /* @@ -349,10 +352,11 @@ static void run_test(enum vm_guest_mode mode, void *arg) static void help(char *name) { puts(""); - printf("usage: %s [-h] [-i iterations] [-p offset] [-g] " + printf("usage: %s [-h] [-a] [-i iterations] [-p offset] [-g] " "[-m mode] [-n] [-b vcpu bytes] [-v vcpus] [-o] [-r random seed ] [-s mem type]" "[-x memslots] [-w percentage]\n", name); puts(""); + printf(" -a: access memory randomly rather than in order.\n"); printf(" -i: specify iteration counts (default: %"PRIu64")\n", TEST_HOST_LOOP_N); printf(" -g: Do not enable KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2. This\n" @@ -403,8 +407,11 @@ int main(int argc, char *argv[]) guest_modes_append_default(); - while ((opt = getopt(argc, argv, "ghi:p:m:nb:v:or:s:x:w:")) != -1) { + while ((opt = getopt(argc, argv, "aghi:p:m:nb:v:or:s:x:w:")) != -1) { switch (opt) { + case 'a': + p.random_access = true; + break; case 'g': dirty_log_manual_caps = 0; break; diff --git a/tools/testing/selftests/kvm/include/perf_test_util.h b/tools/testing/selftests/kvm/include/perf_test_util.h index f93f2ea7c6a3..d9664a31e01c 100644 --- a/tools/testing/selftests/kvm/include/perf_test_util.h +++ b/tools/testing/selftests/kvm/include/perf_test_util.h @@ -39,6 +39,7 @@ struct perf_test_args { /* Run vCPUs in L2 instead of L1, if the architecture supports it. */ bool nested; + bool random_access; struct perf_test_vcpu_args vcpu_args[KVM_MAX_VCPUS]; }; @@ -53,6 +54,7 @@ void perf_test_destroy_vm(struct kvm_vm *vm); void perf_test_set_write_percent(struct kvm_vm *vm, uint32_t write_percent); void perf_test_set_random_seed(struct kvm_vm *vm, uint32_t random_seed); +void perf_test_set_random_access(struct kvm_vm *vm, bool random_access); void perf_test_start_vcpu_threads(int vcpus, void (*vcpu_fn)(struct perf_test_vcpu_args *)); void perf_test_join_vcpu_threads(int vcpus); diff --git a/tools/testing/selftests/kvm/lib/perf_test_util.c b/tools/testing/selftests/kvm/lib/perf_test_util.c index 9effd229b75d..6b196d003491 100644 --- a/tools/testing/selftests/kvm/lib/perf_test_util.c +++ b/tools/testing/selftests/kvm/lib/perf_test_util.c @@ -46,6 +46,7 @@ void perf_test_guest_code(uint32_t vcpu_id) struct perf_test_vcpu_args *vcpu_args = &pta->vcpu_args[vcpu_id]; uint64_t gva; uint64_t pages; + uint64_t addr; int i; uint32_t rand = pta->random_seed + vcpu_id; @@ -57,7 +58,17 @@ void perf_test_guest_code(uint32_t vcpu_id) while (true) { for (i = 0; i < pages; i++) { - uint64_t addr = gva + (i * pta->guest_page_size); + guest_random(&rand); + + if (pta->random_access) + addr = gva + ((rand % pages) * pta->guest_page_size); + else + addr = gva + (i * pta->guest_page_size); + + /* + * Use a new random number here so read/write + * is not tied to the address used. + */ guest_random(&rand); if (rand % 100 < pta->write_percent) @@ -232,6 +243,12 @@ void perf_test_set_random_seed(struct kvm_vm *vm, uint32_t random_seed) sync_global_to_guest(vm, perf_test_args.random_seed); } +void perf_test_set_random_access(struct kvm_vm *vm, bool random_access) +{ + perf_test_args.random_access = random_access; + sync_global_to_guest(vm, perf_test_args.random_access); +} + uint64_t __weak perf_test_nested_pages(int nr_vcpus) { return 0;