From patchwork Mon Nov 7 18:22:05 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 13035074 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 93F86C433FE for ; Mon, 7 Nov 2022 18:22:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232471AbiKGSWj (ORCPT ); Mon, 7 Nov 2022 13:22:39 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38676 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232085AbiKGSWg (ORCPT ); Mon, 7 Nov 2022 13:22:36 -0500 Received: from mail-yw1-x114a.google.com (mail-yw1-x114a.google.com [IPv6:2607:f8b0:4864:20::114a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 91938B56 for ; Mon, 7 Nov 2022 10:22:33 -0800 (PST) Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-360b9418f64so114390797b3.7 for ; Mon, 07 Nov 2022 10:22:33 -0800 (PST) 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:message-id:reply-to; bh=5F1HQsOyjh1Vv5cVsbFCGWYbBVnWvtObjqi8ChAEuPU=; b=f/KDzAG4vBKh8BGHJ0KL8fPOWldM4TTkJMK49wLeo17mFpPO4Ul5YWjHWy0gHdI5rm XKIaZHR6Q/H9cnjgk6rs6maGR9yb/yD9kjfYv0O6DtaQV1YQA6V42qD69fuegJuuO/KI Djw49FhIenFOlAqqQbkUuL7fIHGjx0BLXYvX6A4JPi1M7ugFkxa2kDmbX+/d5EY/VBxC Vfl97x/VFi7eGtnFE6ULq9xP4avtwaCFolzNoZPqCNtB/cGZUcr7p0QvIyM7cDp0Joc7 /h1jpzQrLIemPnX8X5kdc1nWEs9vkA7yQs4QQ+eV+Kpc+8eASfJz5A3aH+VfnFwt98j1 oryw== 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:message-id:reply-to; bh=5F1HQsOyjh1Vv5cVsbFCGWYbBVnWvtObjqi8ChAEuPU=; b=1CGrOzbLOmirwJRBiJE3uFl2nBSeJCxzrhgXdgAGmEbXACU1TQ2JTHDl1R0LtSKG83 xwH55u98O8YooH7zsA7w9IBRvNsAUiOldWuXmnU71w2Ahx/xAD5tB+nllbOu+t3u4lt8 s2sVXT+OkOijek8fddTxdkRYS+WVf5odpO0aMbZLRGnFM/VDxf09d13BTn0o0qcPmDbd niA27R+KKz18WmSbk6+W9K6e/E6g2MMTDohlu3jOyJXblpHmcHHLyz4u52t61UOmwn36 i7ACdkkeBu2C+SHSc8/VFafTMQPVKByo1pc5muLjm3QxNAAetgd5nUZf4tX14MXs78fK bp2Q== X-Gm-Message-State: ACrzQf0qwj/ZWPAb5a0c0K+KxNB6fOAdy4W11Qm5BNsCC8VISc2KfS0P hso81DQhgAZGX0fR7PdCZ0qcsDjZ+bVoI7KBlKMdHvUiI/zlLGvT+7izEFuzLISr6SRhYbDa99G aIEUKEt1sFd5XgW8hsq1G4+8K3PzObvDWkZD+vAl83pHzMlgXXw/QTsejOd+14T/RqPTjmGc= X-Google-Smtp-Source: AMsMyM6qVecqLuwFkaw/FwMzlo7t65bdAhjD6H5SPJrwztlrCB34FMk7XC9fPLGd6BIO39lthO9t2awEYgSNHoIlVQ== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a05:6902:18a:b0:6cc:2d7b:4721 with SMTP id t10-20020a056902018a00b006cc2d7b4721mr50282853ybh.12.1667845352839; Mon, 07 Nov 2022 10:22:32 -0800 (PST) Date: Mon, 7 Nov 2022 18:22:05 +0000 In-Reply-To: <20221107182208.479157-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20221107182208.479157-1-coltonlewis@google.com> X-Mailer: git-send-email 2.38.1.431.g37b22c650d-goog Message-ID: <20221107182208.479157-2-coltonlewis@google.com> Subject: [PATCH v10 1/4] KVM: selftests: implement random number generator 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, Colton Lewis Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Implement random number generator for guest code to randomize parts of the test, making it less predictable and a more accurate reflection of reality. 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. Signed-off-by: Colton Lewis Reviewed-by: Sean Christopherson Reviewed-by: David Matlack --- tools/testing/selftests/kvm/include/test_util.h | 7 +++++++ tools/testing/selftests/kvm/lib/test_util.c | 17 +++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/tools/testing/selftests/kvm/include/test_util.h b/tools/testing/selftests/kvm/include/test_util.h index befc754ce9b3..9e4f36a1a8b0 100644 --- a/tools/testing/selftests/kvm/include/test_util.h +++ b/tools/testing/selftests/kvm/include/test_util.h @@ -152,4 +152,11 @@ static inline void *align_ptr_up(void *x, size_t size) return (void *)align_up((unsigned long)x, size); } +struct guest_random_state { + uint32_t seed; +}; + +struct guest_random_state new_guest_random_state(uint32_t seed); +uint32_t guest_random_u32(struct guest_random_state *state); + #endif /* SELFTEST_KVM_TEST_UTIL_H */ diff --git a/tools/testing/selftests/kvm/lib/test_util.c b/tools/testing/selftests/kvm/lib/test_util.c index 6d23878bbfe1..c4d2749fb2c3 100644 --- a/tools/testing/selftests/kvm/lib/test_util.c +++ b/tools/testing/selftests/kvm/lib/test_util.c @@ -17,6 +17,23 @@ #include "test_util.h" +/* + * Random number generator that is usable from guest code. This is the + * Park-Miller LCG using standard constants. + */ + +struct guest_random_state new_guest_random_state(uint32_t seed) +{ + struct guest_random_state s = {.seed = seed}; + return s; +} + +uint32_t guest_random_u32(struct guest_random_state *state) +{ + state->seed = (uint64_t)state->seed * 48271 % ((uint32_t)(1 << 31) - 1); + return state->seed; +} + /* * Parses "[0-9]+[kmgt]?". */ From patchwork Mon Nov 7 18:22:06 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 13035073 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 A6869C4332F for ; Mon, 7 Nov 2022 18:22:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232400AbiKGSWh (ORCPT ); Mon, 7 Nov 2022 13:22:37 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38678 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232108AbiKGSWg (ORCPT ); Mon, 7 Nov 2022 13:22:36 -0500 Received: from mail-io1-xd4a.google.com (mail-io1-xd4a.google.com [IPv6:2607:f8b0:4864:20::d4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CE1881145B for ; Mon, 7 Nov 2022 10:22:34 -0800 (PST) Received: by mail-io1-xd4a.google.com with SMTP id n23-20020a056602341700b00689fc6dbfd6so7619102ioz.8 for ; Mon, 07 Nov 2022 10:22:34 -0800 (PST) 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:message-id:reply-to; bh=A8Fhf+GP7H/Uvmif/i8F8YNTUSAgb4QsWbaUg89LRpA=; b=q0qb93OWaflcmiJ+5i/YFAC8tg0aZPsr+Uor4bG6W6QyuEY9+cKdcVQ20TW51UZ6rh 5R+HZU87eQGW3BEpweQD9Tf0lK/ROj1c593ZO2/mjytsougpER1eBF+h/EB9paASkzTC h4ai4lJSCIBxVFQ/HxQGbToNW7Az+b7hGFmIdZDqbTgW/NGtIfBgBArKyYTe378PRiKm BluOSL4hS2G/6zFS9hRnoWyfimFkJslnwX7diCKZLUPR2rtGw4i/nmoy+u5ujK+UaJSK SFaPoosM9BpYHfDlGheuaxhlgXNNnd38tfY2dMNTZRErPz0qEfMKIOthxC3GxTToNdGy 3ObA== 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:message-id:reply-to; bh=A8Fhf+GP7H/Uvmif/i8F8YNTUSAgb4QsWbaUg89LRpA=; b=uwLNzyvmXUU9fu9zZCfhssw/YUCKmFwpnXQPdelmm3P7SDtr5dnAEA5ji/iMdR5g1T poy2TDPLk+tlpAYk1Xt8nxagHaRsI4mJauA0Tcy9zOBgrKcw8zxFnqxE1waloHHVxNWx TjCDe/bo1WpfwNPcOJaHFOlf1dh1+T652fh9eRxQTIDYZtWVJY3G08CIsaecsZVfoG61 pelpoWGctpBEGOozAxlmnYeHhf9CbhnuPkNkXk0dS2FRxbS97ZOtervRpWwuOJOhD45Y egfX6fQKvL/+7chMg5Lfbs/UdYPsEnOqgsBMEweGNo0CU269hNaP+CyZ0C0avQvIDrXN mqWA== X-Gm-Message-State: ACrzQf23BqIDf0CEqJqnKgF1IY1soktblCkl94u3XQT8QfnAqqb2GdhP 6nw0f3jPPOplkLHEnx1tn6H/er9vgnXTtDF5qmWN3qhz4Meo2oMMXgndnTlyoLryg8uhCk+C9lj /QVj3qUF3TwWnRBxnwOMorhp3Mzck3QOCGay+5CY7uTYrSXnEJAITJ8zVcNccFXzfPA/lrJE= X-Google-Smtp-Source: AMsMyM7F+/6XUxgpD6TL+vF1FKyfOJDlqdLctNy8kfeN6m9pH6qPLnv8w/Zuf+25C+6XLwokslTwVVmiAehaGQVT+w== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a6b:3103:0:b0:6ce:e628:dba9 with SMTP id j3-20020a6b3103000000b006cee628dba9mr28087339ioa.151.1667845353839; Mon, 07 Nov 2022 10:22:33 -0800 (PST) Date: Mon, 7 Nov 2022 18:22:06 +0000 In-Reply-To: <20221107182208.479157-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20221107182208.479157-1-coltonlewis@google.com> X-Mailer: git-send-email 2.38.1.431.g37b22c650d-goog Message-ID: <20221107182208.479157-3-coltonlewis@google.com> Subject: [PATCH v10 2/4] KVM: selftests: create -r argument to specify random seed 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, Colton Lewis Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Create a -r argument to specify a random seed. If no argument is provided, the seed defaults to 1. The random seed is set with perf_test_set_random_seed() and must be set before guest_code runs to apply. Signed-off-by: Colton Lewis Reviewed-by: David Matlack --- tools/testing/selftests/kvm/dirty_log_perf_test.c | 14 ++++++++++++-- .../testing/selftests/kvm/include/perf_test_util.h | 2 ++ tools/testing/selftests/kvm/lib/perf_test_util.c | 6 ++++++ 3 files changed, 20 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 f99e39a672d3..f74a78138df3 100644 --- a/tools/testing/selftests/kvm/dirty_log_perf_test.c +++ b/tools/testing/selftests/kvm/dirty_log_perf_test.c @@ -132,6 +132,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) @@ -225,6 +226,8 @@ static void run_test(enum vm_guest_mode mode, void *arg) p->slots, p->backing_src, p->partition_vcpu_memory_access); + 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->page_shift; @@ -352,7 +355,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", @@ -380,6 +383,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"); @@ -396,6 +400,7 @@ int main(int argc, char *argv[]) .partition_vcpu_memory_access = true, .backing_src = DEFAULT_VM_MEM_SRC, .slots = 1, + .random_seed = 1, }; int opt; @@ -406,7 +411,7 @@ int main(int argc, char *argv[]) guest_modes_append_default(); - while ((opt = getopt(argc, argv, "eghi:p:m:nb:f:v:os:x:")) != -1) { + while ((opt = getopt(argc, argv, "eghi:p:m:nb:f:v:or:s:x:")) != -1) { switch (opt) { case 'e': /* 'e' is for evil. */ @@ -442,6 +447,11 @@ int main(int argc, char *argv[]) case 'o': p.partition_vcpu_memory_access = false; break; + case 'r': + p.random_seed = atoi(optarg); + TEST_ASSERT(p.random_seed > 0, + "Invalid random seed, must be greater than 0"); + 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 eaa88df0555a..f1050fd42d10 100644 --- a/tools/testing/selftests/kvm/include/perf_test_util.h +++ b/tools/testing/selftests/kvm/include/perf_test_util.h @@ -35,6 +35,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. */ @@ -52,6 +53,7 @@ struct kvm_vm *perf_test_create_vm(enum vm_guest_mode mode, int nr_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/lib/perf_test_util.c b/tools/testing/selftests/kvm/lib/perf_test_util.c index 9618b37c66f7..0bb0659b9a0d 100644 --- a/tools/testing/selftests/kvm/lib/perf_test_util.c +++ b/tools/testing/selftests/kvm/lib/perf_test_util.c @@ -229,6 +229,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; From patchwork Mon Nov 7 18:22:07 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 13035076 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 DBB4FC4332F for ; Mon, 7 Nov 2022 18:22:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232564AbiKGSWl (ORCPT ); Mon, 7 Nov 2022 13:22:41 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38710 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231865AbiKGSWh (ORCPT ); Mon, 7 Nov 2022 13:22:37 -0500 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 859771118 for ; Mon, 7 Nov 2022 10:22:35 -0800 (PST) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-36fc0644f51so115047477b3.17 for ; Mon, 07 Nov 2022 10:22:35 -0800 (PST) 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:message-id:reply-to; bh=UCmXKpIYK2jDAtwwusb7rCkxaR7huRvuHuLP+E7RSxA=; b=NdFxpGjaQt/wCFKovrfNt9+7TFTktuX7BuItxvagYjkB8YTPjhvKJ8c/TlsdhFzKQv eUIuxTzOWb+ysAaxcOY+SsRZ+uvxztzWjmV5NI01zk4npRzLsqtWh8hGbQz0oJxAmJyp kQwM4Bg7KmWOwswSsfFVrQmvmcS7R5NZSGDtYsxSo76Lr0jbT6iL4d/dp923+Sz/dymo OOAHas013HE1GzARKTWS+sN6B0TvZCNbnpEFOusHt+Un0rtoGe75/2A+hHETiLt1oJpa 1LjGtBejQRdlNP6yUhgcm3o1OFPxQqDmLKkvQoSW274bdsG0jBRZJiqdstKjNQE49OeN M+6g== 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:message-id:reply-to; bh=UCmXKpIYK2jDAtwwusb7rCkxaR7huRvuHuLP+E7RSxA=; b=m7t2XiZrw7OkHqPLK2NXfLgK58RlBINa5v8K3qxtT3x0alH9tVjJ/MhFNbvRLjMwu0 VOdccNJT1BuemxjLz5sK4V8NI6Ao1r2AinPzMgwKxmrqq1xYwa5Mw4gb3shFoM93qSVe 2A9O/NwZhVn0aSIiw4wfjR38HOmWzx29K7fA/VtR1UVHInyHbb6g3i+bE9RtnzkDfj8S eBIU18lxxXBgOt0/JNQ+tJYfOidcLooKEjYinVBszpnqa2t1OHfHyL/Nif40s04xsIG2 8NSyMtdHZ8+KsPHtNwQCCsnuq3b1MpmQmDQgjrM025FFu6HS41C9P8PrAj+g6jEXGONs 91gA== X-Gm-Message-State: ACrzQf0jirM19wmQMGKM8y+VaI9OBPRcc3DrLX2EMcP5QJlry9EBnv8M Jes6lPXI83I5sTmW8Q8Dyg//sNLrUQbP7imxI2pMftLugRcoyayWBn55Zfd3fr9fDr9lPvgEfVa opRWD1h0neRZ7rjJ2Rqn+/zGw8VSwr4h89W3OX0BBMqFTTyOKSZ8Le3asvsuZgeYCqf6I4Cw= X-Google-Smtp-Source: AMsMyM5Kx4mh2yYlOZ7S8Ane+15Y6L4tJ8NUTmvTMvThU0LUwNcu67+XmljAgTQ4UrZiXbb/RxAGfcHrZM5nvcB+Eg== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a81:5344:0:b0:360:9535:bde3 with SMTP id h65-20020a815344000000b003609535bde3mr49924850ywb.344.1667845354765; Mon, 07 Nov 2022 10:22:34 -0800 (PST) Date: Mon, 7 Nov 2022 18:22:07 +0000 In-Reply-To: <20221107182208.479157-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20221107182208.479157-1-coltonlewis@google.com> X-Mailer: git-send-email 2.38.1.431.g37b22c650d-goog Message-ID: <20221107182208.479157-4-coltonlewis@google.com> Subject: [PATCH v10 3/4] 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, 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. Each vCPU calculates its own random seed by adding its index to the seed provided. Signed-off-by: Colton Lewis Reviewed-by: David Matlack --- .../selftests/kvm/access_tracking_perf_test.c | 2 +- .../selftests/kvm/dirty_log_perf_test.c | 38 ++++++++++++------- .../selftests/kvm/include/perf_test_util.h | 4 +- .../selftests/kvm/lib/perf_test_util.c | 12 +++--- 4 files changed, 35 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 76c583a07ea2..3e16d5bd7856 100644 --- a/tools/testing/selftests/kvm/access_tracking_perf_test.c +++ b/tools/testing/selftests/kvm/access_tracking_perf_test.c @@ -279,7 +279,7 @@ static void run_iteration(struct kvm_vm *vm, int nr_vcpus, const char *descripti static void access_memory(struct kvm_vm *vm, int nr_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, nr_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 f74a78138df3..a78c617ea2b4 100644 --- a/tools/testing/selftests/kvm/dirty_log_perf_test.c +++ b/tools/testing/selftests/kvm/dirty_log_perf_test.c @@ -128,10 +128,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; }; @@ -228,7 +228,7 @@ static void run_test(enum vm_guest_mode mode, void *arg) 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); + perf_test_set_write_percent(vm, p->write_percent); guest_num_pages = (nr_vcpus * guest_percpu_mem_size) >> vm->page_shift; guest_num_pages = vm_adjust_num_guest_pages(mode, guest_num_pages); @@ -251,6 +251,14 @@ static void run_test(enum vm_guest_mode mode, void *arg) for (i = 0; i < nr_vcpus; i++) vcpu_last_completed_iteration[i] = -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 */ @@ -272,6 +280,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 @@ -356,7 +366,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); @@ -376,10 +386,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"); @@ -387,6 +393,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); } @@ -396,11 +407,11 @@ 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, .random_seed = 1, + .write_percent = 100, }; int opt; @@ -411,7 +422,7 @@ int main(int argc, char *argv[]) guest_modes_append_default(); - while ((opt = getopt(argc, argv, "eghi:p:m:nb:f:v:or:s:x:")) != -1) { + while ((opt = getopt(argc, argv, "eghi:p:m:nb:v:or:s:x:w:")) != -1) { switch (opt) { case 'e': /* 'e' is for evil. */ @@ -434,10 +445,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 f1050fd42d10..845165001ec8 100644 --- a/tools/testing/selftests/kvm/include/perf_test_util.h +++ b/tools/testing/selftests/kvm/include/perf_test_util.h @@ -36,7 +36,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; @@ -52,7 +52,7 @@ struct kvm_vm *perf_test_create_vm(enum vm_guest_mode mode, int nr_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 0bb0659b9a0d..92b47f71a0a5 100644 --- a/tools/testing/selftests/kvm/lib/perf_test_util.c +++ b/tools/testing/selftests/kvm/lib/perf_test_util.c @@ -49,6 +49,8 @@ void perf_test_guest_code(uint32_t vcpu_idx) uint64_t gva; uint64_t pages; int i; + struct guest_random_state rand_state = + new_guest_random_state(pta->random_seed + vcpu_idx); gva = vcpu_args->gva; pages = vcpu_args->pages; @@ -60,7 +62,7 @@ void perf_test_guest_code(uint32_t vcpu_idx) for (i = 0; i < pages; i++) { uint64_t addr = gva + (i * pta->guest_page_size); - if (i % pta->wr_fract == 0) + if (guest_random_u32(&rand_state) % 100 < pta->write_percent) *(uint64_t *)addr = 0x0123456789ABCDEF; else READ_ONCE(*(uint64_t *)addr); @@ -121,7 +123,7 @@ struct kvm_vm *perf_test_create_vm(enum vm_guest_mode mode, int nr_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 @@ -223,10 +225,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 Nov 7 18:22:08 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 13035075 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 466CEC4332F for ; Mon, 7 Nov 2022 18:22:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232518AbiKGSWk (ORCPT ); Mon, 7 Nov 2022 13:22:40 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38698 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232360AbiKGSWh (ORCPT ); Mon, 7 Nov 2022 13:22:37 -0500 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 72C3613FB7 for ; Mon, 7 Nov 2022 10:22:36 -0800 (PST) Received: by mail-io1-xd49.google.com with SMTP id bf14-20020a056602368e00b006ce86e80414so7582191iob.7 for ; Mon, 07 Nov 2022 10:22:36 -0800 (PST) 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:message-id:reply-to; bh=Ro8EPKg0qJQpeO1j55KLBwg/vhsPlixbwUJbwaDMc/E=; b=a00iBNsi68OFyD51+5CStEs54BNyHYVb4y5LRj+gFy8zG4D5dibYqK3no4lgc2jC2f XNepo9xbvMFdNncaD8SPmjucN5ZMU/MuugVt67B3woj+kZP6GH3/G6pjYP5LioFG3+da pP/HKl+TCgK0Lz9QtKZ84J1O+cmwxMAerJvnADgrOaom41s3zvrByo7CsQtXirCSlnaV PsX12ZuQAebNP14JIoc+evMIlO0HWlK7gPMs2RxafGAv4Wn5T3IEGZGIfeWwZ28uNLS+ V72dO0CD7ELsV7YabmOpA8wMH4VpahlmRl7r1B5MdpDKNwbMj8XeA/Iaz/vtev8Q+AXc nERA== 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:message-id:reply-to; bh=Ro8EPKg0qJQpeO1j55KLBwg/vhsPlixbwUJbwaDMc/E=; b=h9Wre47lTWbGFDMWRQErQEWOn0a3etfICfo5msOQGWoO/EquA45jc0sQ20+gbTb9TB PyySbprlCBNRu1TO0XOxH8y57/dYSxJfks3tZgZnNJaicqFRDPh3sxY4yajplCRg21Dx jZxUBlJUOaq51qSZq4GeHfLoHoHTrDRnMvHbMgPpmqpUN9CJEsIl45bkNFgCQ//v8d6M FY4ZDz2NGZE6j8sO3jqODiOSBrJ0oKUDEACQ5oq9xlWrgZcFs8UEwQt0Z9Cpux4c7Kbb APFaZ6TvgGdvBpDi7yVfmTyw1nT4xx5kl+51nh5Cim5RG+lT870CyWnhyzZiXZlwvHFQ GJYQ== X-Gm-Message-State: ANoB5pm9byNIoMzH1RP9cWPYhrcP1kB+XGiteS4fa08Zy6gthLylpOCp tGLzPgDDEabfnarquia2/CnIm5Ou59mKZe6QbrGXllgLI0IdqYYA9RYeV6SVv0wPGN6NDs4LXeW AX37jkGHN6m19UX1VC25U4KkXKI02PTJmuN5pHLRD46ah44SGBOhx5m3CzTl7hPO8SDym6x4= X-Google-Smtp-Source: AA0mqf65lq3/iLj4w9oeddQ7cbH+aW2VsGLhLscOSBw+v6KehDWToch34KB3FcWyPD7oUyqLtyS3n0vTBW8Eu3Mkdw== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a02:998d:0:b0:375:c016:a077 with SMTP id a13-20020a02998d000000b00375c016a077mr5118329jal.80.1667845355716; Mon, 07 Nov 2022 10:22:35 -0800 (PST) Date: Mon, 7 Nov 2022 18:22:08 +0000 In-Reply-To: <20221107182208.479157-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20221107182208.479157-1-coltonlewis@google.com> X-Mailer: git-send-email 2.38.1.431.g37b22c650d-goog Message-ID: <20221107182208.479157-5-coltonlewis@google.com> Subject: [PATCH v10 4/4] 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, 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: David Matlack --- tools/testing/selftests/kvm/dirty_log_perf_test.c | 11 +++++++++-- .../selftests/kvm/include/perf_test_util.h | 2 ++ tools/testing/selftests/kvm/lib/perf_test_util.c | 15 ++++++++++++++- 3 files changed, 25 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 a78c617ea2b4..202f38a72851 100644 --- a/tools/testing/selftests/kvm/dirty_log_perf_test.c +++ b/tools/testing/selftests/kvm/dirty_log_perf_test.c @@ -133,6 +133,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) @@ -259,6 +260,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 */ @@ -281,6 +283,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) { /* @@ -364,10 +367,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" @@ -422,8 +426,11 @@ int main(int argc, char *argv[]) guest_modes_append_default(); - while ((opt = getopt(argc, argv, "eghi:p:m:nb:v:or:s:x:w:")) != -1) { + while ((opt = getopt(argc, argv, "aeghi:p:m:nb:v:or:s:x:w:")) != -1) { switch (opt) { + case 'a': + p.random_access = true; + break; case 'e': /* 'e' is for evil. */ run_vcpus_while_disabling_dirty_logging = true; diff --git a/tools/testing/selftests/kvm/include/perf_test_util.h b/tools/testing/selftests/kvm/include/perf_test_util.h index 845165001ec8..3d0b75ea866a 100644 --- a/tools/testing/selftests/kvm/include/perf_test_util.h +++ b/tools/testing/selftests/kvm/include/perf_test_util.h @@ -40,6 +40,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]; }; @@ -54,6 +55,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 92b47f71a0a5..137be359b09e 100644 --- a/tools/testing/selftests/kvm/lib/perf_test_util.c +++ b/tools/testing/selftests/kvm/lib/perf_test_util.c @@ -48,6 +48,8 @@ void perf_test_guest_code(uint32_t vcpu_idx) struct perf_test_vcpu_args *vcpu_args = &pta->vcpu_args[vcpu_idx]; uint64_t gva; uint64_t pages; + uint64_t addr; + uint64_t page; int i; struct guest_random_state rand_state = new_guest_random_state(pta->random_seed + vcpu_idx); @@ -60,7 +62,12 @@ void perf_test_guest_code(uint32_t vcpu_idx) while (true) { for (i = 0; i < pages; i++) { - uint64_t addr = gva + (i * pta->guest_page_size); + if (pta->random_access) + page = guest_random_u32(&rand_state) % pages; + else + page = i; + + addr = gva + (page * pta->guest_page_size); if (guest_random_u32(&rand_state) % 100 < pta->write_percent) *(uint64_t *)addr = 0x0123456789ABCDEF; @@ -237,6 +244,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;