From patchwork Thu Oct 27 20:56:28 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 13022840 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 52712FA3747 for ; Thu, 27 Oct 2022 21:04:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237393AbiJ0VER (ORCPT ); Thu, 27 Oct 2022 17:04:17 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:46258 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236152AbiJ0VDS (ORCPT ); Thu, 27 Oct 2022 17:03:18 -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 0FE44B05 for ; Thu, 27 Oct 2022 13:57:02 -0700 (PDT) Received: by mail-io1-xd49.google.com with SMTP id w6-20020a6bd606000000b006bcd951c261so2161488ioa.2 for ; Thu, 27 Oct 2022 13:57:02 -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:message-id:reply-to; bh=w+ebisBkWPJ5RfFeeP4pPr1G3UX4W/TiA76RvuNqNLA=; b=ZjdvwkrRMlhvSLfD5kKtUE/tigBMjTjznRjvYEOrjPe74SLU7gD59enpZVak2r0hUh MsMX4ZmafqeKn6mUz04IxR/7dSsWdSDltuBO12TbxvJNuCPfeEdFOrUmLogJO2mk7Y7J jZvpkhNT+WSCa2OwyJd/vJbMuawt0LEJq37ml6T7qxVUZpwE5lf+df7rA2PWsoVOymi8 vwfpOxl7V54EFvVDyDINGGeeXLUxprwDcDLfon3ljV7rDQFCt0AUQHEsRygcEYQqnvf3 C/BOiSUZ9LyzRFPmgkzaeZdj0beVS16Ur+0Jgm28q6Kw0JuYXVZpvFBpx0Au/TxJUAvg o4mQ== 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=w+ebisBkWPJ5RfFeeP4pPr1G3UX4W/TiA76RvuNqNLA=; b=wft5VWL45XkLU7G43TLgmwOEMo8dCMhFTHela1fOqsYLyu6Zf+ryAgVu9uX7oI5mgP R9UdnwUVRdEFgcTfecyuGFs+ucs1PS1cd/ur/wWlcmaH61xgjZQO/kwMc3VFqB6nyElp LfU1W1cMTU3Dqftvudu7bNUhb4m6YujjaMoUi1qp90yFUXCP1CB+qvfC2ORSyIYs4OPB CbI1ymaE2egOJBZ+4vml6sfLPJ6WbDhgk57IvUEKSu2nMaYAbTDLR3xYLhmXnfoa7AsI F8CkT+KgY4AHCml5k8eFmpMZwN7NX6JOoZvzwpxqX4zml+7dOEQJwGTN5s273WhmFHtS 3ePw== X-Gm-Message-State: ACrzQf0VAbbhqgsD2awHzMfmFzz00gYQ+urfj170RavbYTCRPCnq3jyg SliFcAVh2jYiJwSToPU0znIxKRiZcnE2DJenGX9G7sgE6C6kJfUu29ZMKnPihAxMX6qRRuxi4L3 jDRwSitoeW0XC/e7uJtyx60utRV01CFanAVJARdmi1SNJBpOSZEWt90JN4Au6Hvpvw3+Ty1c= X-Google-Smtp-Source: AMsMyM6e8iG0MQgrjrHwVUKo7RGkDRhmmxtlk2KKCHiu0t8FXwxHM/AhkgoQ5WRtfEbSfNLCE+FbUXwnWDbqIwgVKA== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a05:6e02:1561:b0:300:3d37:6296 with SMTP id k1-20020a056e02156100b003003d376296mr9830290ilu.233.1666904221444; Thu, 27 Oct 2022 13:57:01 -0700 (PDT) Date: Thu, 27 Oct 2022 20:56:28 +0000 In-Reply-To: <20221027205631.340339-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20221027205631.340339-1-coltonlewis@google.com> X-Mailer: git-send-email 2.38.1.273.g43a17bfeac-goog Message-ID: <20221027205631.340339-2-coltonlewis@google.com> Subject: [PATCH v8 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. Each vCPU calculates its own seed by adding its index to the seed provided. Signed-off-by: Colton Lewis --- 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 Thu Oct 27 20:56:29 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 13022838 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 4350CFA3748 for ; Thu, 27 Oct 2022 21:04:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237375AbiJ0VEO (ORCPT ); Thu, 27 Oct 2022 17:04:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49378 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236384AbiJ0VDS (ORCPT ); Thu, 27 Oct 2022 17:03:18 -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 D2E309526A for ; Thu, 27 Oct 2022 13:57:02 -0700 (PDT) Received: by mail-io1-xd49.google.com with SMTP id f17-20020a5d8591000000b006bcbe59b6cdso2169825ioj.14 for ; Thu, 27 Oct 2022 13:57:02 -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:message-id:reply-to; bh=y5eYIYEMsC/jQPMR/QSjFg9rOVcWw1Z3eVOiEG1XRd4=; b=lLRwcXfjkh7yXiP6Y58F8BImI6OGP5mXUbMJb5khTI8lEHAyaYqCpAsBLJpEz60shT Wp8N2R1I1oohCHEcOgymiZP1rsEPbFhnVnijZAL9kogBqCx6765aQ+cCb/mw3MNyc8lt +TdWJOoCD00LQxs6h+TUGEFlKuP5KVOi7/kjdaZdSbxwri6EKpuJy1N+IJwAZVO/5KW9 WvN9Bx7NmFFVpfucFigmQz/QtAscBNz92iY278s5uX0gnJGpgQrEn6/DGdkyL/ToEz6e X2HxWsFGjEjaXqotn9ZseyEI82bXD3FnpqT3PCkASJPNImJQo+SdwiUNsfbd25/EL2JI VxIQ== 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=y5eYIYEMsC/jQPMR/QSjFg9rOVcWw1Z3eVOiEG1XRd4=; b=yJK4WiXXOX1TAaNfvUF1i5wuJzCcgfEPQzvcmP2TYtQPxMYf7C9zOCzh06yAXRl6PZ Y7JkbURlj6LdfX9ge7ZWqzXRbyRRL7Ar0fcwP43u9cpfZ2t4wLAuXY4AMDlBnd3fqtoR h+nVv7MuYHX0tsKhgwOqSUlsFG4IYYs0/ygiOQNDa7vNpv2vkPtLxC6VMUnkCjcnskUf 8w8ztMZFHOO5ooN0mG0OkU3WebpBmzrq3/wcdaiqujwoSUEvOLY9be3LIODUd+eYEAGf 04BPEjA9Wh9jILJwzo/w4TbhHfW85QKpVZnYdAQa2+6B1R9VA1UrqhILdjPU5xKfR5M9 qFJA== X-Gm-Message-State: ACrzQf0Ms3bfEx+hhEjOiB3vggl4vtbtnx9rf+5tL1RJduyYGGvQT/qN +j15wQBBj5ppAgB04HWKv7x3tPgMX60pwEoXjUgCvYeNBVolTJZlqZRzAdHkr/U0j9BOniZvLlu iFnmZvFwB15Df+nY4rMO04qKSLMBNNQhoOEynPxwaQLkUTkO4upfQjN42nV11ZoijfgANT4w= X-Google-Smtp-Source: AMsMyM5T6g3PUPcqcjM6ve0GwOnFYjSs1JncksyIDjjT/VecMGmGRkr98UdaWDRywaHSxDPEBOqGC2+R5zckraysGA== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a92:c24f:0:b0:300:1003:d7ab with SMTP id k15-20020a92c24f000000b003001003d7abmr12108172ilo.10.1666904222279; Thu, 27 Oct 2022 13:57:02 -0700 (PDT) Date: Thu, 27 Oct 2022 20:56:29 +0000 In-Reply-To: <20221027205631.340339-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20221027205631.340339-1-coltonlewis@google.com> X-Mailer: git-send-email 2.38.1.273.g43a17bfeac-goog Message-ID: <20221027205631.340339-3-coltonlewis@google.com> Subject: [PATCH v8 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 --- tools/testing/selftests/kvm/dirty_log_perf_test.c | 12 ++++++++++-- tools/testing/selftests/kvm/include/perf_test_util.h | 2 ++ tools/testing/selftests/kvm/lib/perf_test_util.c | 7 +++++++ 3 files changed, 19 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..c97a5e455699 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,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 1. */ + pr_info("Random seed: %u\n", p->random_seed); + perf_test_set_random_seed(vm, p->random_seed ? p->random_seed : 1); perf_test_set_wr_fract(vm, p->wr_fract); guest_num_pages = (nr_vcpus * guest_percpu_mem_size) >> vm->page_shift; @@ -352,7 +356,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 +384,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"); @@ -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,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 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..5f0eebb626b5 100644 --- a/tools/testing/selftests/kvm/lib/perf_test_util.c +++ b/tools/testing/selftests/kvm/lib/perf_test_util.c @@ -49,6 +49,7 @@ 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; @@ -229,6 +230,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 Thu Oct 27 20:56:30 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 13022841 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 589BCFA3749 for ; Thu, 27 Oct 2022 21:04:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S237413AbiJ0VEU (ORCPT ); Thu, 27 Oct 2022 17:04:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:46372 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236640AbiJ0VDS (ORCPT ); Thu, 27 Oct 2022 17:03:18 -0400 Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0561195E4D for ; Thu, 27 Oct 2022 13:57:04 -0700 (PDT) Received: by mail-yb1-xb49.google.com with SMTP id h7-20020a252107000000b006cbb0e24adaso2636981ybh.13 for ; Thu, 27 Oct 2022 13:57:03 -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:message-id:reply-to; bh=DmK22AOz9w6/ahREHk6VXVng3+/kk9B2xWyz0NHbMCo=; b=HcaQotyC6lV7eRCe/fvgCYJoHFzhhYdIqx7lBGSdYaY6fAA/l/p1EurTseKb19o4Wn 99XdZuDmJ2peMPTkQL35Cvz/+1y84NAETlEokxhrYdPj4uJJNOiq9/eEqirc0a16XC5f cgvElCdA23jjXNZ3mScepoK9xqzRCquFQo5C+W9ectSUBrkaQdN5V9UT+a5fzZtRHmxC UPnPcAI+u+KCWp9mLdccwxuvFkLNf5WfigIbMyQcefa6Xpv83zEhlUFBficB5yrHKDrQ qJb9VCfLPnzJiJd783onYEz+/93oUDFbrICzidKeoRTs0Tg7CNT0ObQzkgHCLWa2WOMT CZJg== 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=DmK22AOz9w6/ahREHk6VXVng3+/kk9B2xWyz0NHbMCo=; b=o1KQT0zptmctD684/RJueAlQps1riV0+Ciz4zkIQGXUVe5rQB6f2PPiMr3lD0fjGsq 3I9Hs34LiaacB6PiJ1lpUBpFVmU3BXb7G/xYRDt7ywG/dYn24HBj0Nhj7X1O8VtFhu3h SoNv4tcYvaoEAWkMIEM2UCxlWxxuZjd9WsIBm60LgYUvtifSwvlFpXiH5rIIoMie0Sdp EU5HWcD3EaQMQHCe4ShEUtEU06F4p2zSSETmNmqyZ+sSC7jrSPetw0LZ4k8ZuhtECgOy rMR60c9Lb/qbuGcqK0AAPuLsxrMT/QmjhQzgAtf2Roaej1BTYuABGcZUuJ1D/MsTeRL3 AXCA== X-Gm-Message-State: ACrzQf1snWrJsQb17UIZox5TFaCK7XAWXFhb5ENo0c45uUxTipdFDqf2 2sAR31m9HRwQ1+Afp4jiViux8xgasz1M4oIRRoSJ98o4D6x8P5X3uF3GYsTuzHsCCD3h9Nx41/1 Q1linzK7LeoR9zIY9iX4qUhlvvZZuX1W/9mWMhKk3JA4qgX4f4ydlH5HTJfNlWYoGB75OUW0= X-Google-Smtp-Source: AMsMyM7Ql4DZXGmXP+ezhEFaTyinTXDoJv6hsLHxBfM7kbXt7rvxnUQGIdmJPr2Ox5rs3c0PC9S23c+QTA2CaNxKEQ== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a5b:ccf:0:b0:6b3:ae46:1646 with SMTP id e15-20020a5b0ccf000000b006b3ae461646mr46519395ybr.74.1666904223264; Thu, 27 Oct 2022 13:57:03 -0700 (PDT) Date: Thu, 27 Oct 2022 20:56:30 +0000 In-Reply-To: <20221027205631.340339-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20221027205631.340339-1-coltonlewis@google.com> X-Mailer: git-send-email 2.38.1.273.g43a17bfeac-goog Message-ID: <20221027205631.340339-4-coltonlewis@google.com> Subject: [PATCH v8 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. Signed-off-by: Colton Lewis --- .../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 | 10 ++--- 4 files changed, 33 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 c97a5e455699..0d0240041acf 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; }; @@ -229,7 +229,7 @@ static void run_test(enum vm_guest_mode mode, void *arg) /* If no argument provided, random seed will be 1. */ pr_info("Random seed: %u\n", p->random_seed); perf_test_set_random_seed(vm, p->random_seed ? p->random_seed : 1); - 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); @@ -252,6 +252,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 */ @@ -273,6 +281,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 @@ -357,7 +367,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); @@ -377,10 +387,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"); @@ -388,6 +394,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); } @@ -397,10 +408,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; @@ -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 5f0eebb626b5..97a402f5ed23 100644 --- a/tools/testing/selftests/kvm/lib/perf_test_util.c +++ b/tools/testing/selftests/kvm/lib/perf_test_util.c @@ -61,7 +61,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); @@ -122,7 +122,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 @@ -224,10 +224,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 Thu Oct 27 20:56:31 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Colton Lewis X-Patchwork-Id: 13022842 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 A506DFA3740 for ; Thu, 27 Oct 2022 21:04:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235703AbiJ0VEW (ORCPT ); Thu, 27 Oct 2022 17:04:22 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53948 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235879AbiJ0VDS (ORCPT ); Thu, 27 Oct 2022 17:03:18 -0400 Received: from mail-yb1-xb49.google.com (mail-yb1-xb49.google.com [IPv6:2607:f8b0:4864:20::b49]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EDFF395E7C for ; Thu, 27 Oct 2022 13:57:04 -0700 (PDT) Received: by mail-yb1-xb49.google.com with SMTP id v81-20020a252f54000000b006cb87d7042cso2623682ybv.20 for ; Thu, 27 Oct 2022 13:57:04 -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:message-id:reply-to; bh=mI1bL1qNldSt5bf6jYcLSpbsLUF8bpRTLV/Bcwyx20g=; b=XvKEwPq0OIlPNKjHDmCVgfLM1Cum7YeYDMJ5i3UDa0Pmb4Vq9ANaHtbK/OwOXrTXfR +85EEMDi5xbA6gdB28nLD4/M4jxLhoHJ/ba/hL3JoWEZVMnrm+9+7gf81HO+aQZzG8li YKnOoKSOCF6JettDVJrHxnCEnrPcr9F/KTfAphsOKVI9UKJsuRtgelXMrxXIBV+NiakG RgMjLOUnnrJ/vACMxiz/aCk+GEMFEQNhtrmoAUVRLFRyoGxCMzjFoE6l0/fiF3ZredK8 IP8tdynuEuRiTENAI0jfYMmJmITTSS7xZ2EkHHME9Io2fc9Xm860tTF/UDAn2y9K5DRG hFiw== 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=mI1bL1qNldSt5bf6jYcLSpbsLUF8bpRTLV/Bcwyx20g=; b=OBkg3mPUfE0NNcaThO2I8ZJRW3p/njyZWJ+BsLqE71v8YtYsRz9m0lQ3yDCVSaQGd/ bntqSm3JMNScHQAqn6xqA73IL3rCOK6oByHszK3XHofLA5pH+kYhXq7Umv7mFCNoNNKD IW2O7Yl/nhDhLwfuyIQlJ17fFRCC90t/enAzDThUnZ+tSI814c9+0DBKpfMEFr6V6QBm Su6z2WAU9aL4aB7ckuLiw/oUlZ9eS8qFHbKH8GQsp1M0/uRtZinybDLszxpiLZ/WzZf8 JY+juYI/M6k4AkpPKgEIfI1E5T1oUV5byiRgUFFtV7IzHLoLeyugW9lOwwXVbrK9azpX Gecg== X-Gm-Message-State: ACrzQf02hZx5apAKh+u+V4f3hMRm8pZLipxPQ1ZMBdH0Y22xfZtRNDgc dcNULA9gv3rTnGNI6OS+5QAINhq4FZseiMNx2EfYXyt9MWSrS5OfxqXqZV8NIPSjmHeQqL6Eejg DbBT/KlYNkZ/gkBnN7vvzm2KfOC6Mrmb5TL/MpXljvfUOmpLhUgYIHV4iSiOqfmms9x+bDSw= X-Google-Smtp-Source: AMsMyM5Uul9mjTcNdF2avz+gD00UUsV3Ee0nRwPkPh60EGXVrrSW3lMKv0tm0DoKexw6dnDP6modQELgvHBSfAlHUQ== X-Received: from coltonlewis-kvm.c.googlers.com ([fda3:e722:ac3:cc00:2b:ff92:c0a8:14ce]) (user=coltonlewis job=sendgmr) by 2002:a81:17d1:0:b0:36a:6185:fb06 with SMTP id 200-20020a8117d1000000b0036a6185fb06mr30459759ywx.351.1666904224235; Thu, 27 Oct 2022 13:57:04 -0700 (PDT) Date: Thu, 27 Oct 2022 20:56:31 +0000 In-Reply-To: <20221027205631.340339-1-coltonlewis@google.com> Mime-Version: 1.0 References: <20221027205631.340339-1-coltonlewis@google.com> X-Mailer: git-send-email 2.38.1.273.g43a17bfeac-goog Message-ID: <20221027205631.340339-5-coltonlewis@google.com> Subject: [PATCH v8 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 --- 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 0d0240041acf..065961943b3d 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) @@ -260,6 +261,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 */ @@ -282,6 +284,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) { /* @@ -365,10 +368,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 97a402f5ed23..a27405a590ba 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); @@ -59,7 +61,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; @@ -236,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;