From patchwork Thu Jan 18 03:23:50 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Pierrick Bouvier X-Patchwork-Id: 763600 Delivered-To: patch@linaro.org Received: by 2002:a5d:6e5d:0:b0:337:62d3:c6d5 with SMTP id j29csp589572wrz; Wed, 17 Jan 2024 19:24:58 -0800 (PST) X-Google-Smtp-Source: AGHT+IHxixPoUBi0RaU+Al4BN+UUyTEmcXPfoPlHWZFn4m8PgJGh+3wRoqON3aZbyR+c414wcccl X-Received: by 2002:a05:622a:5c7:b0:42a:14fa:8f3c with SMTP id d7-20020a05622a05c700b0042a14fa8f3cmr253474qtb.11.1705548297867; Wed, 17 Jan 2024 19:24:57 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1705548297; cv=none; d=google.com; s=arc-20160816; b=VGhXv9wq/FrPI16DEdCfBxgGf5Vh6/lunS/aCkSN3KSF4502aG0bzDHJTkATb6cfWA swuxZeCKirnKWmclKowmI+k0VM2siK8XoxNrUXALIF8rxrCutbkrZP/UMQ1SS7dBUd40 VAr4Jd1LJl5xMKuB/tsmX44D1pC7IM/BDCJcM+5qRefpyPcZzSMop7L5iTloZanQOERP xIBIbijxn5fR1vFMkys3AxpYySdeYqBzvMDh7DPBzpvw7vE7UY6rc9iELG6891iIy+hl GrpcK8TURmBe5KEQHqcPikyh1HL63SDf2r1bflryb3Jd/fdEH+tWA2jq6KTF68/wiB1u Y2Vg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature; bh=oP8DElGhxgrlgCtIGb2Ytj2mtZyUCbfff7H8LKle7FM=; fh=2e6Nkd059oxyN734d2Q7Nq9y1HEjPsJBCkEwQXCC3ww=; b=0LpOlQYlICPwAVkPMqhYVk5DhG/A0eVxaZLoSjOlmxiqIJCc3rT/Zt/LTnsuVKmlHF te1TSrvs05EuOJvXT48nAsY6NYlJ6ee35nMiR11M4zIeMUIz7gK6SCnrHbtY8qp7+kqF jOcdn8KJs1cA+8zIsnVT/7ngaBoNs9LjAju/UMBf7b9ADKPEtEdqNWv+sQB/Q1Lp8bNM jywNZscXCQy3N1u0wSzfJjknFFwdHBxqz5eQMwv02cfIFLs2aNseL2tbddd1LJnjuxjU h4zQmujEk5hBEoDBWpHiQThoyN9lIiY6Xkm6lpXmI+57B8v2qXgi202i5nvJ6aFsoxld V+OQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=lfyupez8; spf=pass (google.com: domain of qemu-devel-bounces+patch=linaro.org@nongnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom="qemu-devel-bounces+patch=linaro.org@nongnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from lists.gnu.org (lists.gnu.org. [209.51.188.17]) by mx.google.com with ESMTPS id b16-20020a05620a04f000b00781cc3f5103si12494346qkh.511.2024.01.17.19.24.57 for (version=TLS1_2 cipher=ECDHE-ECDSA-CHACHA20-POLY1305 bits=256/256); Wed, 17 Jan 2024 19:24:57 -0800 (PST) Received-SPF: pass (google.com: domain of qemu-devel-bounces+patch=linaro.org@nongnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=lfyupez8; spf=pass (google.com: domain of qemu-devel-bounces+patch=linaro.org@nongnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom="qemu-devel-bounces+patch=linaro.org@nongnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1rQJ19-0003ek-QF; Wed, 17 Jan 2024 22:24:35 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1rQJ16-0003b9-2v for qemu-devel@nongnu.org; Wed, 17 Jan 2024 22:24:32 -0500 Received: from mail-wm1-x332.google.com ([2a00:1450:4864:20::332]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1rQJ13-0002cj-Ve for qemu-devel@nongnu.org; Wed, 17 Jan 2024 22:24:31 -0500 Received: by mail-wm1-x332.google.com with SMTP id 5b1f17b1804b1-40e7065b7bdso47198155e9.3 for ; Wed, 17 Jan 2024 19:24:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1705548268; x=1706153068; darn=nongnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=oP8DElGhxgrlgCtIGb2Ytj2mtZyUCbfff7H8LKle7FM=; b=lfyupez8eTNOe6aSKBJxzIPAnFWCCtPSx5DFORO8MQUDITTA6fSzGs1lCUmVQJC6QJ LmwJghH6yvr8AjxIhE9xp1CsrujxfBtxCZcyt6cnakX7O6IJ7qpN8bbPZ2+zPFfkJzTR A/l0MaJR5ou2jXmySI9WtdVD9TDzdcfCu7ew453PwikjlzeGuHOHCMBTr8QYTQ4qG/H4 mUf3OvIZApjF3gsYoruS3V7UewpJ1sGMTPLO0UsmPO6a6QbYu1W/+aoecUFJYjHIXQlc uopVZRLeNonetyHnPyycj9z8/tOyPQrk7EwfcApM3VPnFq9oCSLIRJyvhXIuYGW7DeEs UuLQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1705548268; x=1706153068; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=oP8DElGhxgrlgCtIGb2Ytj2mtZyUCbfff7H8LKle7FM=; b=wib48YrAZF+d5T6YW2XhfcyJ8FKELWGYFaJgqEiGyw+gJzjYKfZFUX9GYxjsgqW48z PmtyCrvCxJr075RJobKsL+9uigDDrUhBbceNYeiQIG5LCRomwq04XlzYpS0ts6mDG2qY AmYrZTY3zr2ANmZ5J5squq1AlGMPTAMhxbHdWyFkNIpxEHu/gJrNqhJ+qO77FvVLywsT qb7yfwaHiIBReYY3VgZK5ZKA/b27sPxG3V5uHR1R1z/2VXZnPk1qZlmPrpvFeLemJ22P l4YykOKaDt2v5UBqgtGjXXgGG8z9HcwyRFO2+BhjVbBTWzpRzU2083gtDk9fq/+OVqEM CxKQ== X-Gm-Message-State: AOJu0YwcA1vmXQC4BnxijvTTOLkpte9jezErqWAmQaWszPq8Af2nVET5 dtOQgxtWMKGOI2FBdE4OwzhaC5bt56u2i1Cx9vnTBK7oH5rrbTmLuQ0ksV/4QaZnxbH4OogEnEu Cvo0= X-Received: by 2002:a7b:cb8d:0:b0:40d:8550:878d with SMTP id m13-20020a7bcb8d000000b0040d8550878dmr74695wmi.15.1705548267823; Wed, 17 Jan 2024 19:24:27 -0800 (PST) Received: from linaro.. ([102.35.208.160]) by smtp.gmail.com with ESMTPSA id i2-20020adff302000000b0033788e357e1sm2894292wro.108.2024.01.17.19.24.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Jan 2024 19:24:27 -0800 (PST) From: Pierrick Bouvier To: qemu-devel@nongnu.org Cc: Mahmoud Mandour , Paolo Bonzini , Pierrick Bouvier , Richard Henderson , =?utf-8?q?Alex_Benn=C3=A9?= =?utf-8?q?e?= , Alexandre Iooss Subject: [PATCH v2 05/14] tests/plugin: add test plugin for inline operations Date: Thu, 18 Jan 2024 07:23:50 +0400 Message-ID: <20240118032400.3762658-6-pierrick.bouvier@linaro.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240118032400.3762658-1-pierrick.bouvier@linaro.org> References: <20240118032400.3762658-1-pierrick.bouvier@linaro.org> MIME-Version: 1.0 Received-SPF: pass client-ip=2a00:1450:4864:20::332; envelope-from=pierrick.bouvier@linaro.org; helo=mail-wm1-x332.google.com X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+patch=linaro.org@nongnu.org Sender: qemu-devel-bounces+patch=linaro.org@nongnu.org For now, it simply performs instruction, bb and mem count, and ensure that inline vs callback versions have the same result. Later, we'll extend it when new inline operations are added. Use existing plugins to test everything works is a bit cumbersome, as different events are treated in different plugins. Thus, this new one. Signed-off-by: Pierrick Bouvier Reviewed-by: Alex Bennée --- tests/plugin/inline.c | 182 +++++++++++++++++++++++++++++++++++++++ tests/plugin/meson.build | 2 +- 2 files changed, 183 insertions(+), 1 deletion(-) create mode 100644 tests/plugin/inline.c diff --git a/tests/plugin/inline.c b/tests/plugin/inline.c new file mode 100644 index 00000000000..28d1c3b1e48 --- /dev/null +++ b/tests/plugin/inline.c @@ -0,0 +1,182 @@ +/* + * Copyright (C) 2023, Pierrick Bouvier + * + * Demonstrates and tests usage of inline ops. + * + * License: GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#include +#include +#include + +#include + +typedef struct { + uint64_t count_tb; + uint64_t count_tb_inline; + uint64_t count_insn; + uint64_t count_insn_inline; + uint64_t count_mem; + uint64_t count_mem_inline; +} CPUCount; + +static struct qemu_plugin_scoreboard *counts; +static qemu_plugin_u64_t count_tb; +static qemu_plugin_u64_t count_tb_inline; +static qemu_plugin_u64_t count_insn; +static qemu_plugin_u64_t count_insn_inline; +static qemu_plugin_u64_t count_mem; +static qemu_plugin_u64_t count_mem_inline; + +static uint64_t global_count_tb; +static uint64_t global_count_insn; +static uint64_t global_count_mem; +static unsigned int max_cpu_index; +static GMutex tb_lock; +static GMutex insn_lock; +static GMutex mem_lock; + +QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION; + +static void stats_insn(void) +{ + const uint64_t expected = global_count_insn; + const uint64_t per_vcpu = qemu_plugin_u64_sum(count_insn); + const uint64_t inl_per_vcpu = + qemu_plugin_u64_sum(count_insn_inline); + printf("insn: %" PRIu64 "\n", expected); + printf("insn: %" PRIu64 " (per vcpu)\n", per_vcpu); + printf("insn: %" PRIu64 " (per vcpu inline)\n", inl_per_vcpu); + g_assert(expected > 0); + g_assert(per_vcpu == expected); + g_assert(inl_per_vcpu == expected); +} + +static void stats_tb(void) +{ + const uint64_t expected = global_count_tb; + const uint64_t per_vcpu = qemu_plugin_u64_sum(count_tb); + const uint64_t inl_per_vcpu = + qemu_plugin_u64_sum(count_tb_inline); + printf("tb: %" PRIu64 "\n", expected); + printf("tb: %" PRIu64 " (per vcpu)\n", per_vcpu); + printf("tb: %" PRIu64 " (per vcpu inline)\n", inl_per_vcpu); + g_assert(expected > 0); + g_assert(per_vcpu == expected); + g_assert(inl_per_vcpu == expected); +} + +static void stats_mem(void) +{ + const uint64_t expected = global_count_mem; + const uint64_t per_vcpu = qemu_plugin_u64_sum(count_mem); + const uint64_t inl_per_vcpu = + qemu_plugin_u64_sum(count_mem_inline); + printf("mem: %" PRIu64 "\n", expected); + printf("mem: %" PRIu64 " (per vcpu)\n", per_vcpu); + printf("mem: %" PRIu64 " (per vcpu inline)\n", inl_per_vcpu); + g_assert(expected > 0); + g_assert(per_vcpu == expected); + g_assert(inl_per_vcpu == expected); +} + +static void plugin_exit(qemu_plugin_id_t id, void *udata) +{ + const unsigned int num_cpus = qemu_plugin_scoreboard_size(counts); + g_assert(num_cpus == max_cpu_index + 1); + + for (int i = 0; i < num_cpus ; ++i) { + const uint64_t tb = *qemu_plugin_u64_get(count_tb, i); + const uint64_t tb_inline = *qemu_plugin_u64_get(count_tb_inline, i); + const uint64_t insn = *qemu_plugin_u64_get(count_insn, i); + const uint64_t insn_inline = *qemu_plugin_u64_get(count_insn_inline, i); + const uint64_t mem = *qemu_plugin_u64_get(count_mem, i); + const uint64_t mem_inline = *qemu_plugin_u64_get(count_mem_inline, i); + printf("cpu %d: tb (%" PRIu64 ", %" PRIu64 ") | " + "insn (%" PRIu64 ", %" PRIu64 ") | " + "mem (%" PRIu64 ", %" PRIu64 ")" + "\n", + i, tb, tb_inline, insn, insn_inline, mem, mem_inline); + g_assert(tb == tb_inline); + g_assert(insn == insn_inline); + g_assert(mem == mem_inline); + } + + stats_tb(); + stats_insn(); + stats_mem(); + + qemu_plugin_scoreboard_free(counts); +} + +static void vcpu_tb_exec(unsigned int cpu_index, void *udata) +{ + (*qemu_plugin_u64_get(count_tb, cpu_index))++; + g_mutex_lock(&tb_lock); + max_cpu_index = MAX(max_cpu_index, cpu_index); + global_count_tb++; + g_mutex_unlock(&tb_lock); +} + +static void vcpu_insn_exec(unsigned int cpu_index, void *udata) +{ + (*qemu_plugin_u64_get(count_insn, cpu_index))++; + g_mutex_lock(&insn_lock); + global_count_insn++; + g_mutex_unlock(&insn_lock); +} + +static void vcpu_mem_access(unsigned int cpu_index, + qemu_plugin_meminfo_t info, + uint64_t vaddr, + void *userdata) +{ + (*qemu_plugin_u64_get(count_mem, cpu_index))++; + g_mutex_lock(&mem_lock); + global_count_mem++; + g_mutex_unlock(&mem_lock); +} + +static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb) +{ + qemu_plugin_register_vcpu_tb_exec_cb( + tb, vcpu_tb_exec, QEMU_PLUGIN_CB_NO_REGS, 0); + qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu( + tb, QEMU_PLUGIN_INLINE_ADD_U64, count_tb_inline, 1); + + for (int idx = 0; idx < qemu_plugin_tb_n_insns(tb); ++idx) { + struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, idx); + qemu_plugin_register_vcpu_insn_exec_cb( + insn, vcpu_insn_exec, QEMU_PLUGIN_CB_NO_REGS, 0); + qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu( + insn, QEMU_PLUGIN_INLINE_ADD_U64, count_insn_inline, 1); + qemu_plugin_register_vcpu_mem_cb(insn, &vcpu_mem_access, + QEMU_PLUGIN_CB_NO_REGS, + QEMU_PLUGIN_MEM_RW, 0); + qemu_plugin_register_vcpu_mem_inline_per_vcpu( + insn, QEMU_PLUGIN_MEM_RW, + QEMU_PLUGIN_INLINE_ADD_U64, + count_mem_inline, 1); + } +} + +QEMU_PLUGIN_EXPORT +int qemu_plugin_install(qemu_plugin_id_t id, const qemu_info_t *info, + int argc, char **argv) +{ + counts = qemu_plugin_scoreboard_new(sizeof(CPUCount)); + count_tb = qemu_plugin_u64_struct(counts, CPUCount, count_tb); + count_insn = qemu_plugin_u64_struct(counts, CPUCount, count_insn); + count_mem = qemu_plugin_u64_struct(counts, CPUCount, count_mem); + count_tb_inline = qemu_plugin_u64_struct(counts, CPUCount, count_tb_inline); + count_insn_inline = + qemu_plugin_u64_struct(counts, CPUCount, count_insn_inline); + count_mem_inline = + qemu_plugin_u64_struct(counts, CPUCount, count_mem_inline); + qemu_plugin_register_vcpu_tb_trans_cb(id, vcpu_tb_trans); + qemu_plugin_register_atexit_cb(id, plugin_exit, NULL); + + return 0; +} diff --git a/tests/plugin/meson.build b/tests/plugin/meson.build index e18183aaeda..9eece5bab51 100644 --- a/tests/plugin/meson.build +++ b/tests/plugin/meson.build @@ -1,6 +1,6 @@ t = [] if get_option('plugins') - foreach i : ['bb', 'empty', 'insn', 'mem', 'syscall'] + foreach i : ['bb', 'empty', 'inline', 'insn', 'mem', 'syscall'] if host_os == 'windows' t += shared_module(i, files(i + '.c') + '../../contrib/plugins/win32_linker.c', include_directories: '../../include/qemu',