* [PATCH v6 00/12] TCG Plugin inline operation enhancement
@ 2024-02-29 5:24 Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 01/12] plugins: scoreboard API Pierrick Bouvier
` (11 more replies)
0 siblings, 12 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:24 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
This series adds a new thread-safe API to declare inline operation
inside plugins. As well, it removes the existing non thread-safe API,
and migrates all existing plugins to use it.
Tested on Linux (user, system) for i386, x86_64 and aarch64.
To give some context, this a long term series of work around plugins,
with the goal to be able to do basic operations in a more performant and
accurate way. This will mean to add more inline operations and
conditional callbacks.
One final target of this work is to implement a plugin that implements
the icount=auto feature, and allow QEMU to run at a given "frequency"
based on number of instructions executed, without QEMU needing to keep
track of this.
Another final target is to be able to detect control flow changes in an
efficient and elegant way, by combining inline operation and conditional
callbacks.
v6
--
- fix test/plugins/mem.c double count
- rebase on top of master, now that register api was merged
v5
--
- fix bound for qemu_plugin_u64_loop
- skip double API bump for plugins
- rebase on top of 20240223162202.1936541-1-alex.bennee@linaro.org
Only existing plugins changes still need a review.
v4
--
- split scoreboard/qemu_plugin_u64 patches
- use list instead of hash table to keep track of scoreboards
- remove immediate in tcg code gen
v3
--
- introduce qemu_plugin_num_vcpus (how many cpus were initialized)
- fix order of plugin init/idle/resume callbacks
- scoreboard:
- renamed qemu_plugin_u64_t -> qemu_plugin_u64
- some functions rename for scoreboard api
- qemu_plugin_u64 has only value based function (vs address before)
- various cleanup thanks to review of previous series
v2
--
Implement scoreboard API (cpu local storage), so plugins don't have to deal
with how many cpus are used.
Since plugins have been modified again, I didn't transfer any reviewed-by on
those commits.
Pierrick Bouvier (12):
plugins: scoreboard API
plugins: define qemu_plugin_u64
plugins: implement inline operation relative to cpu_index
plugins: add inline operation per vcpu
tests/plugin: add test plugin for inline operations
tests/plugin/mem: migrate to new per_vcpu API
tests/plugin/insn: migrate to new per_vcpu API
tests/plugin/bb: migrate to new per_vcpu API
contrib/plugins/hotblocks: migrate to new per_vcpu API
contrib/plugins/howvec: migrate to new per_vcpu API
plugins: remove non per_vcpu inline operation from API
plugins: cleanup codepath for previous inline operation
include/qemu/plugin.h | 7 ++
include/qemu/qemu-plugin.h | 142 ++++++++++++++++++++------
plugins/plugin.h | 17 +++-
accel/tcg/plugin-gen.c | 69 ++++++++++---
contrib/plugins/hotblocks.c | 50 ++++++----
contrib/plugins/howvec.c | 53 +++++++---
plugins/api.c | 92 ++++++++++++++---
plugins/core.c | 79 +++++++++++++--
tests/plugin/bb.c | 63 +++++-------
tests/plugin/inline.c | 186 +++++++++++++++++++++++++++++++++++
tests/plugin/insn.c | 106 ++++++++++----------
tests/plugin/mem.c | 46 ++++++---
plugins/qemu-plugins.symbols | 13 ++-
tests/plugin/meson.build | 2 +-
14 files changed, 708 insertions(+), 217 deletions(-)
create mode 100644 tests/plugin/inline.c
--
2.43.0
^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH v6 01/12] plugins: scoreboard API
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
@ 2024-02-29 5:24 ` Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 02/12] plugins: define qemu_plugin_u64 Pierrick Bouvier
` (10 subsequent siblings)
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:24 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
We introduce a cpu local storage, automatically managed (and extended)
by QEMU itself. Plugin allocate a scoreboard, and don't have to deal
with how many cpus are launched.
This API will be used by new inline functions but callbacks can benefit
from this as well. This way, they can operate without a global lock for
simple operations.
At any point during execution, any scoreboard will be dimensioned with
at least qemu_plugin_num_vcpus entries.
New functions:
- qemu_plugin_scoreboard_find
- qemu_plugin_scoreboard_free
- qemu_plugin_scoreboard_new
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
include/qemu/plugin.h | 6 ++++
include/qemu/qemu-plugin.h | 31 ++++++++++++++++++++
plugins/plugin.h | 6 ++++
plugins/api.c | 19 ++++++++++++
plugins/core.c | 57 ++++++++++++++++++++++++++++++++++++
plugins/qemu-plugins.symbols | 3 ++
6 files changed, 122 insertions(+)
diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
index b3c94a34aa4..bf96d2c2aa3 100644
--- a/include/qemu/plugin.h
+++ b/include/qemu/plugin.h
@@ -112,6 +112,12 @@ struct qemu_plugin_insn {
bool mem_only;
};
+/* A scoreboard is an array of values, indexed by vcpu_index */
+struct qemu_plugin_scoreboard {
+ GArray *data;
+ QLIST_ENTRY(qemu_plugin_scoreboard) entry;
+};
+
/*
* qemu_plugin_insn allocate and cleanup functions. We don't expect to
* cleanup many of these structures. They are reused for each fresh
diff --git a/include/qemu/qemu-plugin.h b/include/qemu/qemu-plugin.h
index 45e2ebc8f8f..31c468ddb2c 100644
--- a/include/qemu/qemu-plugin.h
+++ b/include/qemu/qemu-plugin.h
@@ -222,6 +222,8 @@ void qemu_plugin_register_vcpu_resume_cb(qemu_plugin_id_t id,
struct qemu_plugin_tb;
/** struct qemu_plugin_insn - Opaque handle for a translated instruction */
struct qemu_plugin_insn;
+/** struct qemu_plugin_scoreboard - Opaque handle for a scoreboard */
+struct qemu_plugin_scoreboard;
/**
* enum qemu_plugin_cb_flags - type of callback
@@ -752,5 +754,34 @@ QEMU_PLUGIN_API
int qemu_plugin_read_register(struct qemu_plugin_register *handle,
GByteArray *buf);
+/**
+ * qemu_plugin_scoreboard_new() - alloc a new scoreboard
+ *
+ * @element_size: size (in bytes) for one entry
+ *
+ * Returns a pointer to a new scoreboard. It must be freed using
+ * qemu_plugin_scoreboard_free.
+ */
+QEMU_PLUGIN_API
+struct qemu_plugin_scoreboard *qemu_plugin_scoreboard_new(size_t element_size);
+
+/**
+ * qemu_plugin_scoreboard_free() - free a scoreboard
+ * @score: scoreboard to free
+ */
+QEMU_PLUGIN_API
+void qemu_plugin_scoreboard_free(struct qemu_plugin_scoreboard *score);
+
+/**
+ * qemu_plugin_scoreboard_find() - get pointer to an entry of a scoreboard
+ * @score: scoreboard to query
+ * @vcpu_index: entry index
+ *
+ * Returns address of entry of a scoreboard matching a given vcpu_index. This
+ * address can be modified later if scoreboard is resized.
+ */
+QEMU_PLUGIN_API
+void *qemu_plugin_scoreboard_find(struct qemu_plugin_scoreboard *score,
+ unsigned int vcpu_index);
#endif /* QEMU_QEMU_PLUGIN_H */
diff --git a/plugins/plugin.h b/plugins/plugin.h
index 00b3509f708..043c740067d 100644
--- a/plugins/plugin.h
+++ b/plugins/plugin.h
@@ -31,6 +31,8 @@ struct qemu_plugin_state {
* but with the HT we avoid adding a field to CPUState.
*/
GHashTable *cpu_ht;
+ QLIST_HEAD(, qemu_plugin_scoreboard) scoreboards;
+ size_t scoreboard_alloc_size;
DECLARE_BITMAP(mask, QEMU_PLUGIN_EV_MAX);
/*
* @lock protects the struct as well as ctx->uninstalling.
@@ -101,4 +103,8 @@ void exec_inline_op(struct qemu_plugin_dyn_cb *cb);
int plugin_num_vcpus(void);
+struct qemu_plugin_scoreboard *plugin_scoreboard_new(size_t element_size);
+
+void plugin_scoreboard_free(struct qemu_plugin_scoreboard *score);
+
#endif /* PLUGIN_H */
diff --git a/plugins/api.c b/plugins/api.c
index 81f43c9ce8a..f8b15510ff7 100644
--- a/plugins/api.c
+++ b/plugins/api.c
@@ -465,3 +465,22 @@ int qemu_plugin_read_register(struct qemu_plugin_register *reg, GByteArray *buf)
return gdb_read_register(current_cpu, buf, GPOINTER_TO_INT(reg));
}
+
+struct qemu_plugin_scoreboard *qemu_plugin_scoreboard_new(size_t element_size)
+{
+ return plugin_scoreboard_new(element_size);
+}
+
+void qemu_plugin_scoreboard_free(struct qemu_plugin_scoreboard *score)
+{
+ plugin_scoreboard_free(score);
+}
+
+void *qemu_plugin_scoreboard_find(struct qemu_plugin_scoreboard *score,
+ unsigned int vcpu_index)
+{
+ g_assert(vcpu_index < qemu_plugin_num_vcpus());
+ /* we can't use g_array_index since entry size is not statically known */
+ char *base_ptr = score->data->data;
+ return base_ptr + vcpu_index * g_array_get_element_size(score->data);
+}
diff --git a/plugins/core.c b/plugins/core.c
index 2db4d31354b..63f4c6c6ce3 100644
--- a/plugins/core.c
+++ b/plugins/core.c
@@ -18,6 +18,7 @@
#include "qemu/lockable.h"
#include "qemu/option.h"
#include "qemu/plugin.h"
+#include "qemu/queue.h"
#include "qemu/rcu_queue.h"
#include "qemu/xxhash.h"
#include "qemu/rcu.h"
@@ -215,6 +216,35 @@ CPUPluginState *qemu_plugin_create_vcpu_state(void)
return g_new0(CPUPluginState, 1);
}
+static void plugin_grow_scoreboards__locked(CPUState *cpu)
+{
+ if (cpu->cpu_index < plugin.scoreboard_alloc_size) {
+ return;
+ }
+
+ bool need_realloc = FALSE;
+ while (cpu->cpu_index >= plugin.scoreboard_alloc_size) {
+ plugin.scoreboard_alloc_size *= 2;
+ need_realloc = TRUE;
+ }
+
+
+ if (!need_realloc || QLIST_EMPTY(&plugin.scoreboards)) {
+ /* nothing to do, we just updated sizes for future scoreboards */
+ return;
+ }
+
+ /* cpus must be stopped, as tb might still use an existing scoreboard. */
+ start_exclusive();
+ struct qemu_plugin_scoreboard *score;
+ QLIST_FOREACH(score, &plugin.scoreboards, entry) {
+ g_array_set_size(score->data, plugin.scoreboard_alloc_size);
+ }
+ /* force all tb to be flushed, as scoreboard pointers were changed. */
+ tb_flush(cpu);
+ end_exclusive();
+}
+
void qemu_plugin_vcpu_init_hook(CPUState *cpu)
{
bool success;
@@ -225,6 +255,7 @@ void qemu_plugin_vcpu_init_hook(CPUState *cpu)
success = g_hash_table_insert(plugin.cpu_ht, &cpu->cpu_index,
&cpu->cpu_index);
g_assert(success);
+ plugin_grow_scoreboards__locked(cpu);
qemu_rec_mutex_unlock(&plugin.lock);
plugin_vcpu_cb__simple(cpu, QEMU_PLUGIN_EV_VCPU_INIT);
@@ -578,6 +609,8 @@ static void __attribute__((__constructor__)) plugin_init(void)
qemu_rec_mutex_init(&plugin.lock);
plugin.id_ht = g_hash_table_new(g_int64_hash, g_int64_equal);
plugin.cpu_ht = g_hash_table_new(g_int_hash, g_int_equal);
+ QLIST_INIT(&plugin.scoreboards);
+ plugin.scoreboard_alloc_size = 16; /* avoid frequent reallocation */
QTAILQ_INIT(&plugin.ctxs);
qht_init(&plugin.dyn_cb_arr_ht, plugin_dyn_cb_arr_cmp, 16,
QHT_MODE_AUTO_RESIZE);
@@ -588,3 +621,27 @@ int plugin_num_vcpus(void)
{
return plugin.num_vcpus;
}
+
+struct qemu_plugin_scoreboard *plugin_scoreboard_new(size_t element_size)
+{
+ struct qemu_plugin_scoreboard *score =
+ g_malloc0(sizeof(struct qemu_plugin_scoreboard));
+ score->data = g_array_new(FALSE, TRUE, element_size);
+ g_array_set_size(score->data, plugin.scoreboard_alloc_size);
+
+ qemu_rec_mutex_lock(&plugin.lock);
+ QLIST_INSERT_HEAD(&plugin.scoreboards, score, entry);
+ qemu_rec_mutex_unlock(&plugin.lock);
+
+ return score;
+}
+
+void plugin_scoreboard_free(struct qemu_plugin_scoreboard *score)
+{
+ qemu_rec_mutex_lock(&plugin.lock);
+ QLIST_REMOVE(score, entry);
+ qemu_rec_mutex_unlock(&plugin.lock);
+
+ g_array_free(score->data, TRUE);
+ g_free(score);
+}
diff --git a/plugins/qemu-plugins.symbols b/plugins/qemu-plugins.symbols
index 27fe97239be..3f93e7d6b13 100644
--- a/plugins/qemu-plugins.symbols
+++ b/plugins/qemu-plugins.symbols
@@ -37,6 +37,9 @@
qemu_plugin_register_vcpu_tb_exec_inline;
qemu_plugin_register_vcpu_tb_trans_cb;
qemu_plugin_reset;
+ qemu_plugin_scoreboard_free;
+ qemu_plugin_scoreboard_find;
+ qemu_plugin_scoreboard_new;
qemu_plugin_start_code;
qemu_plugin_tb_get_insn;
qemu_plugin_tb_n_insns;
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 02/12] plugins: define qemu_plugin_u64
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 01/12] plugins: scoreboard API Pierrick Bouvier
@ 2024-02-29 5:24 ` Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 03/12] plugins: implement inline operation relative to cpu_index Pierrick Bouvier
` (9 subsequent siblings)
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:24 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
Additionally to the scoreboard, we define a qemu_plugin_u64, which is a
simple struct holding a pointer to a scoreboard, and a given offset.
This allows to have a scoreboard containing structs, without having to
bring offset to operate on a specific field.
Since most of the plugins are simply collecting a sum of per-cpu values,
qemu_plugin_u64 directly support this operation as well.
All inline operations defined later will use a qemu_plugin_u64 as input.
New functions:
- qemu_plugin_u64_add
- qemu_plugin_u64_get
- qemu_plugin_u64_set
- qemu_plugin_u64_sum
New macros:
- qemu_plugin_scoreboard_u64
- qemu_plugin_scoreboard_u64_in_struct
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
include/qemu/qemu-plugin.h | 52 ++++++++++++++++++++++++++++++++++++
plugins/api.c | 34 +++++++++++++++++++++++
plugins/qemu-plugins.symbols | 4 +++
3 files changed, 90 insertions(+)
diff --git a/include/qemu/qemu-plugin.h b/include/qemu/qemu-plugin.h
index 31c468ddb2c..ebf9a645e15 100644
--- a/include/qemu/qemu-plugin.h
+++ b/include/qemu/qemu-plugin.h
@@ -225,6 +225,17 @@ struct qemu_plugin_insn;
/** struct qemu_plugin_scoreboard - Opaque handle for a scoreboard */
struct qemu_plugin_scoreboard;
+/**
+ * typedef qemu_plugin_u64 - uint64_t member of an entry in a scoreboard
+ *
+ * This field allows to access a specific uint64_t member in one given entry,
+ * located at a specified offset. Inline operations expect this as entry.
+ */
+typedef struct {
+ struct qemu_plugin_scoreboard *score;
+ size_t offset;
+} qemu_plugin_u64;
+
/**
* enum qemu_plugin_cb_flags - type of callback
*
@@ -784,4 +795,45 @@ QEMU_PLUGIN_API
void *qemu_plugin_scoreboard_find(struct qemu_plugin_scoreboard *score,
unsigned int vcpu_index);
+/* Macros to define a qemu_plugin_u64 */
+#define qemu_plugin_scoreboard_u64(score) \
+ (qemu_plugin_u64) {score, 0}
+#define qemu_plugin_scoreboard_u64_in_struct(score, type, member) \
+ (qemu_plugin_u64) {score, offsetof(type, member)}
+
+/**
+ * qemu_plugin_u64_add() - add a value to a qemu_plugin_u64 for a given vcpu
+ * @entry: entry to query
+ * @vcpu_index: entry index
+ * @added: value to add
+ */
+QEMU_PLUGIN_API
+void qemu_plugin_u64_add(qemu_plugin_u64 entry, unsigned int vcpu_index,
+ uint64_t added);
+
+/**
+ * qemu_plugin_u64_get() - get value of a qemu_plugin_u64 for a given vcpu
+ * @entry: entry to query
+ * @vcpu_index: entry index
+ */
+QEMU_PLUGIN_API
+uint64_t qemu_plugin_u64_get(qemu_plugin_u64 entry, unsigned int vcpu_index);
+
+/**
+ * qemu_plugin_u64_set() - set value of a qemu_plugin_u64 for a given vcpu
+ * @entry: entry to query
+ * @vcpu_index: entry index
+ * @val: new value
+ */
+QEMU_PLUGIN_API
+void qemu_plugin_u64_set(qemu_plugin_u64 entry, unsigned int vcpu_index,
+ uint64_t val);
+
+/**
+ * qemu_plugin_u64_sum() - return sum of all vcpu entries in a scoreboard
+ * @entry: entry to sum
+ */
+QEMU_PLUGIN_API
+uint64_t qemu_plugin_u64_sum(qemu_plugin_u64 entry);
+
#endif /* QEMU_QEMU_PLUGIN_H */
diff --git a/plugins/api.c b/plugins/api.c
index f8b15510ff7..f4518a68afe 100644
--- a/plugins/api.c
+++ b/plugins/api.c
@@ -484,3 +484,37 @@ void *qemu_plugin_scoreboard_find(struct qemu_plugin_scoreboard *score,
char *base_ptr = score->data->data;
return base_ptr + vcpu_index * g_array_get_element_size(score->data);
}
+
+static uint64_t *plugin_u64_address(qemu_plugin_u64 entry,
+ unsigned int vcpu_index)
+{
+ char *ptr = qemu_plugin_scoreboard_find(entry.score, vcpu_index);
+ return (uint64_t *)(ptr + entry.offset);
+}
+
+void qemu_plugin_u64_add(qemu_plugin_u64 entry, unsigned int vcpu_index,
+ uint64_t added)
+{
+ *plugin_u64_address(entry, vcpu_index) += added;
+}
+
+uint64_t qemu_plugin_u64_get(qemu_plugin_u64 entry,
+ unsigned int vcpu_index)
+{
+ return *plugin_u64_address(entry, vcpu_index);
+}
+
+void qemu_plugin_u64_set(qemu_plugin_u64 entry, unsigned int vcpu_index,
+ uint64_t val)
+{
+ *plugin_u64_address(entry, vcpu_index) = val;
+}
+
+uint64_t qemu_plugin_u64_sum(qemu_plugin_u64 entry)
+{
+ uint64_t total = 0;
+ for (int i = 0, n = qemu_plugin_num_vcpus(); i < n; ++i) {
+ total += qemu_plugin_u64_get(entry, i);
+ }
+ return total;
+}
diff --git a/plugins/qemu-plugins.symbols b/plugins/qemu-plugins.symbols
index 3f93e7d6b13..6204453d0fd 100644
--- a/plugins/qemu-plugins.symbols
+++ b/plugins/qemu-plugins.symbols
@@ -44,6 +44,10 @@
qemu_plugin_tb_get_insn;
qemu_plugin_tb_n_insns;
qemu_plugin_tb_vaddr;
+ qemu_plugin_u64_add;
+ qemu_plugin_u64_get;
+ qemu_plugin_u64_set;
+ qemu_plugin_u64_sum;
qemu_plugin_uninstall;
qemu_plugin_vcpu_for_each;
};
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 03/12] plugins: implement inline operation relative to cpu_index
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 01/12] plugins: scoreboard API Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 02/12] plugins: define qemu_plugin_u64 Pierrick Bouvier
@ 2024-02-29 5:24 ` Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 04/12] plugins: add inline operation per vcpu Pierrick Bouvier
` (8 subsequent siblings)
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:24 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
Instead of working on a fixed memory location, allow to address it based
on cpu_index, an element size and a given offset.
Result address: ptr + offset + cpu_index * element_size.
With this, we can target a member in a struct array from a base pointer.
Current semantic is not modified, thus inline operation still targets
always the same memory location.
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
plugins/plugin.h | 2 +-
accel/tcg/plugin-gen.c | 69 ++++++++++++++++++++++++++++++++++--------
plugins/api.c | 3 +-
plugins/core.c | 12 +++++---
4 files changed, 67 insertions(+), 19 deletions(-)
diff --git a/plugins/plugin.h b/plugins/plugin.h
index 043c740067d..3bf1aaf5c2d 100644
--- a/plugins/plugin.h
+++ b/plugins/plugin.h
@@ -99,7 +99,7 @@ void plugin_register_vcpu_mem_cb(GArray **arr,
enum qemu_plugin_mem_rw rw,
void *udata);
-void exec_inline_op(struct qemu_plugin_dyn_cb *cb);
+void exec_inline_op(struct qemu_plugin_dyn_cb *cb, int cpu_index);
int plugin_num_vcpus(void);
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
index ac6b52b9ec9..0f8be53d394 100644
--- a/accel/tcg/plugin-gen.c
+++ b/accel/tcg/plugin-gen.c
@@ -133,16 +133,28 @@ static void gen_empty_udata_cb_no_rwg(void)
*/
static void gen_empty_inline_cb(void)
{
+ TCGv_i32 cpu_index = tcg_temp_ebb_new_i32();
+ TCGv_ptr cpu_index_as_ptr = tcg_temp_ebb_new_ptr();
TCGv_i64 val = tcg_temp_ebb_new_i64();
TCGv_ptr ptr = tcg_temp_ebb_new_ptr();
+ tcg_gen_ld_i32(cpu_index, tcg_env,
+ -offsetof(ArchCPU, env) + offsetof(CPUState, cpu_index));
+ /* second operand will be replaced by immediate value */
+ tcg_gen_mul_i32(cpu_index, cpu_index, cpu_index);
+ tcg_gen_ext_i32_ptr(cpu_index_as_ptr, cpu_index);
+
tcg_gen_movi_ptr(ptr, 0);
+ tcg_gen_add_ptr(ptr, ptr, cpu_index_as_ptr);
tcg_gen_ld_i64(val, ptr, 0);
- /* pass an immediate != 0 so that it doesn't get optimized away */
- tcg_gen_addi_i64(val, val, 0xdeadface);
+ /* second operand will be replaced by immediate value */
+ tcg_gen_add_i64(val, val, val);
+
tcg_gen_st_i64(val, ptr, 0);
tcg_temp_free_ptr(ptr);
tcg_temp_free_i64(val);
+ tcg_temp_free_ptr(cpu_index_as_ptr);
+ tcg_temp_free_i32(cpu_index);
}
static void gen_empty_mem_cb(TCGv_i64 addr, uint32_t info)
@@ -290,12 +302,37 @@ static TCGOp *copy_const_ptr(TCGOp **begin_op, TCGOp *op, void *ptr)
return op;
}
+static TCGOp *copy_ld_i32(TCGOp **begin_op, TCGOp *op)
+{
+ return copy_op(begin_op, op, INDEX_op_ld_i32);
+}
+
+static TCGOp *copy_ext_i32_ptr(TCGOp **begin_op, TCGOp *op)
+{
+ if (UINTPTR_MAX == UINT32_MAX) {
+ op = copy_op(begin_op, op, INDEX_op_mov_i32);
+ } else {
+ op = copy_op(begin_op, op, INDEX_op_ext_i32_i64);
+ }
+ return op;
+}
+
+static TCGOp *copy_add_ptr(TCGOp **begin_op, TCGOp *op)
+{
+ if (UINTPTR_MAX == UINT32_MAX) {
+ op = copy_op(begin_op, op, INDEX_op_add_i32);
+ } else {
+ op = copy_op(begin_op, op, INDEX_op_add_i64);
+ }
+ return op;
+}
+
static TCGOp *copy_ld_i64(TCGOp **begin_op, TCGOp *op)
{
if (TCG_TARGET_REG_BITS == 32) {
/* 2x ld_i32 */
- op = copy_op(begin_op, op, INDEX_op_ld_i32);
- op = copy_op(begin_op, op, INDEX_op_ld_i32);
+ op = copy_ld_i32(begin_op, op);
+ op = copy_ld_i32(begin_op, op);
} else {
/* ld_i64 */
op = copy_op(begin_op, op, INDEX_op_ld_i64);
@@ -331,6 +368,13 @@ static TCGOp *copy_add_i64(TCGOp **begin_op, TCGOp *op, uint64_t v)
return op;
}
+static TCGOp *copy_mul_i32(TCGOp **begin_op, TCGOp *op, uint32_t v)
+{
+ op = copy_op(begin_op, op, INDEX_op_mul_i32);
+ op->args[2] = tcgv_i32_arg(tcg_constant_i32(v));
+ return op;
+}
+
static TCGOp *copy_st_ptr(TCGOp **begin_op, TCGOp *op)
{
if (UINTPTR_MAX == UINT32_MAX) {
@@ -396,18 +440,17 @@ static TCGOp *append_inline_cb(const struct qemu_plugin_dyn_cb *cb,
TCGOp *begin_op, TCGOp *op,
int *unused)
{
- /* const_ptr */
- op = copy_const_ptr(&begin_op, op, cb->userp);
-
- /* ld_i64 */
+ char *ptr = cb->userp;
+ size_t elem_size = 0;
+ size_t offset = 0;
+ op = copy_ld_i32(&begin_op, op);
+ op = copy_mul_i32(&begin_op, op, elem_size);
+ op = copy_ext_i32_ptr(&begin_op, op);
+ op = copy_const_ptr(&begin_op, op, ptr + offset);
+ op = copy_add_ptr(&begin_op, op);
op = copy_ld_i64(&begin_op, op);
-
- /* add_i64 */
op = copy_add_i64(&begin_op, op, cb->inline_insn.imm);
-
- /* st_i64 */
op = copy_st_i64(&begin_op, op);
-
return op;
}
diff --git a/plugins/api.c b/plugins/api.c
index f4518a68afe..d8b461bc69c 100644
--- a/plugins/api.c
+++ b/plugins/api.c
@@ -106,7 +106,8 @@ void qemu_plugin_register_vcpu_tb_exec_inline(struct qemu_plugin_tb *tb,
void *ptr, uint64_t imm)
{
if (!tb->mem_only) {
- plugin_register_inline_op(&tb->cbs[PLUGIN_CB_INLINE], 0, op, ptr, imm);
+ plugin_register_inline_op(&tb->cbs[PLUGIN_CB_INLINE],
+ 0, op, ptr, imm);
}
}
diff --git a/plugins/core.c b/plugins/core.c
index 63f4c6c6ce3..65d5611f797 100644
--- a/plugins/core.c
+++ b/plugins/core.c
@@ -318,7 +318,8 @@ static struct qemu_plugin_dyn_cb *plugin_get_dyn_cb(GArray **arr)
void plugin_register_inline_op(GArray **arr,
enum qemu_plugin_mem_rw rw,
- enum qemu_plugin_op op, void *ptr,
+ enum qemu_plugin_op op,
+ void *ptr,
uint64_t imm)
{
struct qemu_plugin_dyn_cb *dyn_cb;
@@ -474,9 +475,12 @@ void qemu_plugin_flush_cb(void)
plugin_cb__simple(QEMU_PLUGIN_EV_FLUSH);
}
-void exec_inline_op(struct qemu_plugin_dyn_cb *cb)
+void exec_inline_op(struct qemu_plugin_dyn_cb *cb, int cpu_index)
{
- uint64_t *val = cb->userp;
+ char *ptr = cb->userp;
+ size_t elem_size = 0;
+ size_t offset = 0;
+ uint64_t *val = (uint64_t *)(ptr + offset + cpu_index * elem_size);
switch (cb->inline_insn.op) {
case QEMU_PLUGIN_INLINE_ADD_U64:
@@ -509,7 +513,7 @@ void qemu_plugin_vcpu_mem_cb(CPUState *cpu, uint64_t vaddr,
vaddr, cb->userp);
break;
case PLUGIN_CB_INLINE:
- exec_inline_op(cb);
+ exec_inline_op(cb, cpu->cpu_index);
break;
default:
g_assert_not_reached();
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 04/12] plugins: add inline operation per vcpu
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
` (2 preceding siblings ...)
2024-02-29 5:24 ` [PATCH v6 03/12] plugins: implement inline operation relative to cpu_index Pierrick Bouvier
@ 2024-02-29 5:24 ` Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 05/12] tests/plugin: add test plugin for inline operations Pierrick Bouvier
` (7 subsequent siblings)
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:24 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
Extends API with three new functions:
qemu_plugin_register_vcpu_{tb, insn, mem}_exec_inline_per_vcpu().
Those functions takes a qemu_plugin_u64 as input.
This allows to have a thread-safe and type-safe version of inline
operations.
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
include/qemu/plugin.h | 1 +
include/qemu/qemu-plugin.h | 51 +++++++++++++++++++++++++++++++++++-
plugins/plugin.h | 6 +++++
accel/tcg/plugin-gen.c | 7 +++++
plugins/api.c | 37 +++++++++++++++++++++++++-
plugins/core.c | 23 ++++++++++++++++
plugins/qemu-plugins.symbols | 3 +++
7 files changed, 126 insertions(+), 2 deletions(-)
diff --git a/include/qemu/plugin.h b/include/qemu/plugin.h
index bf96d2c2aa3..12a96cea2a4 100644
--- a/include/qemu/plugin.h
+++ b/include/qemu/plugin.h
@@ -92,6 +92,7 @@ struct qemu_plugin_dyn_cb {
/* fields specific to each dyn_cb type go here */
union {
struct {
+ qemu_plugin_u64 entry;
enum qemu_plugin_op op;
uint64_t imm;
} inline_insn;
diff --git a/include/qemu/qemu-plugin.h b/include/qemu/qemu-plugin.h
index ebf9a645e15..6bbad068c01 100644
--- a/include/qemu/qemu-plugin.h
+++ b/include/qemu/qemu-plugin.h
@@ -328,6 +328,22 @@ void qemu_plugin_register_vcpu_tb_exec_inline(struct qemu_plugin_tb *tb,
enum qemu_plugin_op op,
void *ptr, uint64_t imm);
+/**
+ * qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu() - execution inline op
+ * @tb: the opaque qemu_plugin_tb handle for the translation
+ * @op: the type of qemu_plugin_op (e.g. ADD_U64)
+ * @entry: entry to run op
+ * @imm: the op data (e.g. 1)
+ *
+ * Insert an inline op on a given scoreboard entry.
+ */
+QEMU_PLUGIN_API
+void qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu(
+ struct qemu_plugin_tb *tb,
+ enum qemu_plugin_op op,
+ qemu_plugin_u64 entry,
+ uint64_t imm);
+
/**
* qemu_plugin_register_vcpu_insn_exec_cb() - register insn execution cb
* @insn: the opaque qemu_plugin_insn handle for an instruction
@@ -358,6 +374,22 @@ void qemu_plugin_register_vcpu_insn_exec_inline(struct qemu_plugin_insn *insn,
enum qemu_plugin_op op,
void *ptr, uint64_t imm);
+/**
+ * qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu() - insn exec inline op
+ * @insn: the opaque qemu_plugin_insn handle for an instruction
+ * @op: the type of qemu_plugin_op (e.g. ADD_U64)
+ * @entry: entry to run op
+ * @imm: the op data (e.g. 1)
+ *
+ * Insert an inline op to every time an instruction executes.
+ */
+QEMU_PLUGIN_API
+void qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu(
+ struct qemu_plugin_insn *insn,
+ enum qemu_plugin_op op,
+ qemu_plugin_u64 entry,
+ uint64_t imm);
+
/**
* qemu_plugin_tb_n_insns() - query helper for number of insns in TB
* @tb: opaque handle to TB passed to callback
@@ -583,7 +615,24 @@ void qemu_plugin_register_vcpu_mem_inline(struct qemu_plugin_insn *insn,
enum qemu_plugin_op op, void *ptr,
uint64_t imm);
-
+/**
+ * qemu_plugin_register_vcpu_mem_inline_per_vcpu() - inline op for mem access
+ * @insn: handle for instruction to instrument
+ * @rw: apply to reads, writes or both
+ * @op: the op, of type qemu_plugin_op
+ * @entry: entry to run op
+ * @imm: immediate data for @op
+ *
+ * This registers a inline op every memory access generated by the
+ * instruction.
+ */
+QEMU_PLUGIN_API
+void qemu_plugin_register_vcpu_mem_inline_per_vcpu(
+ struct qemu_plugin_insn *insn,
+ enum qemu_plugin_mem_rw rw,
+ enum qemu_plugin_op op,
+ qemu_plugin_u64 entry,
+ uint64_t imm);
typedef void
(*qemu_plugin_vcpu_syscall_cb_t)(qemu_plugin_id_t id, unsigned int vcpu_index,
diff --git a/plugins/plugin.h b/plugins/plugin.h
index 3bf1aaf5c2d..f6fa10a0f56 100644
--- a/plugins/plugin.h
+++ b/plugins/plugin.h
@@ -73,6 +73,12 @@ void plugin_register_inline_op(GArray **arr,
enum qemu_plugin_op op, void *ptr,
uint64_t imm);
+void plugin_register_inline_op_on_entry(GArray **arr,
+ enum qemu_plugin_mem_rw rw,
+ enum qemu_plugin_op op,
+ qemu_plugin_u64 entry,
+ uint64_t imm);
+
void plugin_reset_uninstall(qemu_plugin_id_t id,
qemu_plugin_simple_cb_t cb,
bool reset);
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
index 0f8be53d394..47e05ec6347 100644
--- a/accel/tcg/plugin-gen.c
+++ b/accel/tcg/plugin-gen.c
@@ -443,6 +443,13 @@ static TCGOp *append_inline_cb(const struct qemu_plugin_dyn_cb *cb,
char *ptr = cb->userp;
size_t elem_size = 0;
size_t offset = 0;
+ if (!ptr) {
+ /* use inline entry */
+ ptr = cb->inline_insn.entry.score->data->data;
+ elem_size = g_array_get_element_size(cb->inline_insn.entry.score->data);
+ offset = cb->inline_insn.entry.offset;
+ }
+
op = copy_ld_i32(&begin_op, op);
op = copy_mul_i32(&begin_op, op, elem_size);
op = copy_ext_i32_ptr(&begin_op, op);
diff --git a/plugins/api.c b/plugins/api.c
index d8b461bc69c..ac3982c6636 100644
--- a/plugins/api.c
+++ b/plugins/api.c
@@ -111,6 +111,18 @@ void qemu_plugin_register_vcpu_tb_exec_inline(struct qemu_plugin_tb *tb,
}
}
+void qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu(
+ struct qemu_plugin_tb *tb,
+ enum qemu_plugin_op op,
+ qemu_plugin_u64 entry,
+ uint64_t imm)
+{
+ if (!tb->mem_only) {
+ plugin_register_inline_op_on_entry(
+ &tb->cbs[PLUGIN_CB_INLINE], 0, op, entry, imm);
+ }
+}
+
void qemu_plugin_register_vcpu_insn_exec_cb(struct qemu_plugin_insn *insn,
qemu_plugin_vcpu_udata_cb_t cb,
enum qemu_plugin_cb_flags flags,
@@ -136,6 +148,18 @@ void qemu_plugin_register_vcpu_insn_exec_inline(struct qemu_plugin_insn *insn,
}
}
+void qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu(
+ struct qemu_plugin_insn *insn,
+ enum qemu_plugin_op op,
+ qemu_plugin_u64 entry,
+ uint64_t imm)
+{
+ if (!insn->mem_only) {
+ plugin_register_inline_op_on_entry(
+ &insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_INLINE], 0, op, entry, imm);
+ }
+}
+
/*
* We always plant memory instrumentation because they don't finalise until
@@ -148,7 +172,7 @@ void qemu_plugin_register_vcpu_mem_cb(struct qemu_plugin_insn *insn,
void *udata)
{
plugin_register_vcpu_mem_cb(&insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_REGULAR],
- cb, flags, rw, udata);
+ cb, flags, rw, udata);
}
void qemu_plugin_register_vcpu_mem_inline(struct qemu_plugin_insn *insn,
@@ -160,6 +184,17 @@ void qemu_plugin_register_vcpu_mem_inline(struct qemu_plugin_insn *insn,
rw, op, ptr, imm);
}
+void qemu_plugin_register_vcpu_mem_inline_per_vcpu(
+ struct qemu_plugin_insn *insn,
+ enum qemu_plugin_mem_rw rw,
+ enum qemu_plugin_op op,
+ qemu_plugin_u64 entry,
+ uint64_t imm)
+{
+ plugin_register_inline_op_on_entry(
+ &insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE], rw, op, entry, imm);
+}
+
void qemu_plugin_register_vcpu_tb_trans_cb(qemu_plugin_id_t id,
qemu_plugin_vcpu_tb_trans_cb_t cb)
{
diff --git a/plugins/core.c b/plugins/core.c
index 65d5611f797..7852590da88 100644
--- a/plugins/core.c
+++ b/plugins/core.c
@@ -332,6 +332,23 @@ void plugin_register_inline_op(GArray **arr,
dyn_cb->inline_insn.imm = imm;
}
+void plugin_register_inline_op_on_entry(GArray **arr,
+ enum qemu_plugin_mem_rw rw,
+ enum qemu_plugin_op op,
+ qemu_plugin_u64 entry,
+ uint64_t imm)
+{
+ struct qemu_plugin_dyn_cb *dyn_cb;
+
+ dyn_cb = plugin_get_dyn_cb(arr);
+ dyn_cb->userp = NULL;
+ dyn_cb->type = PLUGIN_CB_INLINE;
+ dyn_cb->rw = rw;
+ dyn_cb->inline_insn.entry = entry;
+ dyn_cb->inline_insn.op = op;
+ dyn_cb->inline_insn.imm = imm;
+}
+
void plugin_register_dyn_cb__udata(GArray **arr,
qemu_plugin_vcpu_udata_cb_t cb,
enum qemu_plugin_cb_flags flags,
@@ -480,6 +497,12 @@ void exec_inline_op(struct qemu_plugin_dyn_cb *cb, int cpu_index)
char *ptr = cb->userp;
size_t elem_size = 0;
size_t offset = 0;
+ if (!ptr) {
+ /* use inline entry */
+ ptr = cb->inline_insn.entry.score->data->data;
+ elem_size = g_array_get_element_size(cb->inline_insn.entry.score->data);
+ offset = cb->inline_insn.entry.offset;
+ }
uint64_t *val = (uint64_t *)(ptr + offset + cpu_index * elem_size);
switch (cb->inline_insn.op) {
diff --git a/plugins/qemu-plugins.symbols b/plugins/qemu-plugins.symbols
index 6204453d0fd..0d8141b85f1 100644
--- a/plugins/qemu-plugins.symbols
+++ b/plugins/qemu-plugins.symbols
@@ -28,13 +28,16 @@
qemu_plugin_register_vcpu_init_cb;
qemu_plugin_register_vcpu_insn_exec_cb;
qemu_plugin_register_vcpu_insn_exec_inline;
+ qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu;
qemu_plugin_register_vcpu_mem_cb;
qemu_plugin_register_vcpu_mem_inline;
+ qemu_plugin_register_vcpu_mem_inline_per_vcpu;
qemu_plugin_register_vcpu_resume_cb;
qemu_plugin_register_vcpu_syscall_cb;
qemu_plugin_register_vcpu_syscall_ret_cb;
qemu_plugin_register_vcpu_tb_exec_cb;
qemu_plugin_register_vcpu_tb_exec_inline;
+ qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu;
qemu_plugin_register_vcpu_tb_trans_cb;
qemu_plugin_reset;
qemu_plugin_scoreboard_free;
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 05/12] tests/plugin: add test plugin for inline operations
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
` (3 preceding siblings ...)
2024-02-29 5:24 ` [PATCH v6 04/12] plugins: add inline operation per vcpu Pierrick Bouvier
@ 2024-02-29 5:24 ` Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 06/12] tests/plugin/mem: migrate to new per_vcpu API Pierrick Bouvier
` (6 subsequent siblings)
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:24 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
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.
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
tests/plugin/inline.c | 186 +++++++++++++++++++++++++++++++++++++++
tests/plugin/meson.build | 2 +-
2 files changed, 187 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..0163e9b51c5
--- /dev/null
+++ b/tests/plugin/inline.c
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2023, Pierrick Bouvier <pierrick.bouvier@linaro.org>
+ *
+ * Demonstrates and tests usage of inline ops.
+ *
+ * License: GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include <glib.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include <qemu-plugin.h>
+
+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 count_tb;
+static qemu_plugin_u64 count_tb_inline;
+static qemu_plugin_u64 count_insn;
+static qemu_plugin_u64 count_insn_inline;
+static qemu_plugin_u64 count_mem;
+static qemu_plugin_u64 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_num_vcpus();
+ 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_add(count_tb, cpu_index, 1);
+ 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_add(count_insn, cpu_index, 1);
+ 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_add(count_mem, cpu_index, 1);
+ 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_scoreboard_u64_in_struct(
+ counts, CPUCount, count_tb);
+ count_insn = qemu_plugin_scoreboard_u64_in_struct(
+ counts, CPUCount, count_insn);
+ count_mem = qemu_plugin_scoreboard_u64_in_struct(
+ counts, CPUCount, count_mem);
+ count_tb_inline = qemu_plugin_scoreboard_u64_in_struct(
+ counts, CPUCount, count_tb_inline);
+ count_insn_inline = qemu_plugin_scoreboard_u64_in_struct(
+ counts, CPUCount, count_insn_inline);
+ count_mem_inline = qemu_plugin_scoreboard_u64_in_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',
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 06/12] tests/plugin/mem: migrate to new per_vcpu API
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
` (4 preceding siblings ...)
2024-02-29 5:24 ` [PATCH v6 05/12] tests/plugin: add test plugin for inline operations Pierrick Bouvier
@ 2024-02-29 5:25 ` Pierrick Bouvier
2024-02-29 18:08 ` Alex Bennée
2024-02-29 5:25 ` [PATCH v6 07/12] tests/plugin/insn: " Pierrick Bouvier
` (5 subsequent siblings)
11 siblings, 1 reply; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:25 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss, Luc Michel
Reviewed-by: Luc Michel <luc.michel@amd.com>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
tests/plugin/mem.c | 46 +++++++++++++++++++++++++++++++---------------
1 file changed, 31 insertions(+), 15 deletions(-)
diff --git a/tests/plugin/mem.c b/tests/plugin/mem.c
index 44e91065ba7..b650dddcce1 100644
--- a/tests/plugin/mem.c
+++ b/tests/plugin/mem.c
@@ -16,9 +16,14 @@
QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
-static uint64_t inline_mem_count;
-static uint64_t cb_mem_count;
-static uint64_t io_count;
+typedef struct {
+ uint64_t mem_count;
+ uint64_t io_count;
+} CPUCount;
+
+static struct qemu_plugin_scoreboard *counts;
+static qemu_plugin_u64 mem_count;
+static qemu_plugin_u64 io_count;
static bool do_inline, do_callback;
static bool do_haddr;
static enum qemu_plugin_mem_rw rw = QEMU_PLUGIN_MEM_RW;
@@ -27,16 +32,16 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
{
g_autoptr(GString) out = g_string_new("");
- if (do_inline) {
- g_string_printf(out, "inline mem accesses: %" PRIu64 "\n", inline_mem_count);
- }
- if (do_callback) {
- g_string_append_printf(out, "callback mem accesses: %" PRIu64 "\n", cb_mem_count);
+ if (do_inline || do_callback) {
+ g_string_printf(out, "mem accesses: %" PRIu64 "\n",
+ qemu_plugin_u64_sum(mem_count));
}
if (do_haddr) {
- g_string_append_printf(out, "io accesses: %" PRIu64 "\n", io_count);
+ g_string_append_printf(out, "io accesses: %" PRIu64 "\n",
+ qemu_plugin_u64_sum(io_count));
}
qemu_plugin_outs(out->str);
+ qemu_plugin_scoreboard_free(counts);
}
static void vcpu_mem(unsigned int cpu_index, qemu_plugin_meminfo_t meminfo,
@@ -46,12 +51,12 @@ static void vcpu_mem(unsigned int cpu_index, qemu_plugin_meminfo_t meminfo,
struct qemu_plugin_hwaddr *hwaddr;
hwaddr = qemu_plugin_get_hwaddr(meminfo, vaddr);
if (qemu_plugin_hwaddr_is_io(hwaddr)) {
- io_count++;
+ qemu_plugin_u64_add(io_count, cpu_index, 1);
} else {
- cb_mem_count++;
+ qemu_plugin_u64_add(mem_count, cpu_index, 1);
}
} else {
- cb_mem_count++;
+ qemu_plugin_u64_add(mem_count, cpu_index, 1);
}
}
@@ -64,9 +69,10 @@ static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, i);
if (do_inline) {
- qemu_plugin_register_vcpu_mem_inline(insn, rw,
- QEMU_PLUGIN_INLINE_ADD_U64,
- &inline_mem_count, 1);
+ qemu_plugin_register_vcpu_mem_inline_per_vcpu(
+ insn, rw,
+ QEMU_PLUGIN_INLINE_ADD_U64,
+ mem_count, 1);
}
if (do_callback) {
qemu_plugin_register_vcpu_mem_cb(insn, vcpu_mem,
@@ -117,6 +123,16 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
}
}
+ if (do_inline && do_callback) {
+ fprintf(stderr,
+ "can't enable inline and callback counting at the same time\n");
+ return -1;
+ }
+
+ counts = qemu_plugin_scoreboard_new(sizeof(CPUCount));
+ mem_count = qemu_plugin_scoreboard_u64_in_struct(
+ counts, CPUCount, mem_count);
+ io_count = qemu_plugin_scoreboard_u64_in_struct(counts, CPUCount, io_count);
qemu_plugin_register_vcpu_tb_trans_cb(id, vcpu_tb_trans);
qemu_plugin_register_atexit_cb(id, plugin_exit, NULL);
return 0;
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 07/12] tests/plugin/insn: migrate to new per_vcpu API
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
` (5 preceding siblings ...)
2024-02-29 5:25 ` [PATCH v6 06/12] tests/plugin/mem: migrate to new per_vcpu API Pierrick Bouvier
@ 2024-02-29 5:25 ` Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 08/12] tests/plugin/bb: " Pierrick Bouvier
` (4 subsequent siblings)
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:25 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss, Luc Michel
Reviewed-by: Luc Michel <luc.michel@amd.com>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
tests/plugin/insn.c | 106 +++++++++++++++++++++-----------------------
1 file changed, 50 insertions(+), 56 deletions(-)
diff --git a/tests/plugin/insn.c b/tests/plugin/insn.c
index 54da06fcf26..5e0aa03223e 100644
--- a/tests/plugin/insn.c
+++ b/tests/plugin/insn.c
@@ -16,25 +16,21 @@
QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
-#define MAX_CPUS 8 /* lets not go nuts */
-
-typedef struct {
- uint64_t insn_count;
-} InstructionCount;
-
-static InstructionCount counts[MAX_CPUS];
-static uint64_t inline_insn_count;
+static qemu_plugin_u64 insn_count;
static bool do_inline;
static bool do_size;
static GArray *sizes;
+typedef struct {
+ uint64_t hits;
+ uint64_t last_hit;
+ uint64_t total_delta;
+} MatchCount;
+
typedef struct {
char *match_string;
- uint64_t hits[MAX_CPUS];
- uint64_t last_hit[MAX_CPUS];
- uint64_t total_delta[MAX_CPUS];
- GPtrArray *history[MAX_CPUS];
+ struct qemu_plugin_scoreboard *counts; /* MatchCount */
} Match;
static GArray *matches;
@@ -67,41 +63,40 @@ static void vcpu_init(qemu_plugin_id_t id, unsigned int vcpu_index)
static void vcpu_insn_exec_before(unsigned int cpu_index, void *udata)
{
- unsigned int i = cpu_index % MAX_CPUS;
- InstructionCount *c = &counts[i];
-
- c->insn_count++;
+ qemu_plugin_u64_add(insn_count, cpu_index, 1);
}
static void vcpu_insn_matched_exec_before(unsigned int cpu_index, void *udata)
{
- unsigned int i = cpu_index % MAX_CPUS;
Instruction *insn = (Instruction *) udata;
- Match *match = insn->match;
+ Match *insn_match = insn->match;
+ MatchCount *match = qemu_plugin_scoreboard_find(insn_match->counts,
+ cpu_index);
+
g_autoptr(GString) ts = g_string_new("");
insn->hits++;
g_string_append_printf(ts, "0x%" PRIx64 ", '%s', %"PRId64 " hits",
insn->vaddr, insn->disas, insn->hits);
- uint64_t icount = counts[i].insn_count;
- uint64_t delta = icount - match->last_hit[i];
+ uint64_t icount = qemu_plugin_u64_get(insn_count, cpu_index);
+ uint64_t delta = icount - match->last_hit;
- match->hits[i]++;
- match->total_delta[i] += delta;
+ match->hits++;
+ match->total_delta += delta;
g_string_append_printf(ts,
- ", %"PRId64" match hits, "
- "Δ+%"PRId64 " since last match,"
+ " , cpu %u,"
+ " %"PRId64" match hits,"
+ " Δ+%"PRId64 " since last match,"
" %"PRId64 " avg insns/match\n",
- match->hits[i], delta,
- match->total_delta[i] / match->hits[i]);
+ cpu_index,
+ match->hits, delta,
+ match->total_delta / match->hits);
- match->last_hit[i] = icount;
+ match->last_hit = icount;
qemu_plugin_outs(ts->str);
-
- g_ptr_array_add(match->history[i], insn);
}
static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
@@ -113,8 +108,8 @@ static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, i);
if (do_inline) {
- qemu_plugin_register_vcpu_insn_exec_inline(
- insn, QEMU_PLUGIN_INLINE_ADD_U64, &inline_insn_count, 1);
+ qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu(
+ insn, QEMU_PLUGIN_INLINE_ADD_U64, insn_count, 1);
} else {
uint64_t vaddr = qemu_plugin_insn_vaddr(insn);
qemu_plugin_register_vcpu_insn_exec_cb(
@@ -136,10 +131,9 @@ static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
* information about the instruction which we also need to
* save if there is a hit.
*/
- if (matches) {
+ if (matches->len) {
char *insn_disas = qemu_plugin_insn_disas(insn);
- int j;
- for (j = 0; j < matches->len; j++) {
+ for (int j = 0; j < matches->len; j++) {
Match *m = &g_array_index(matches, Match, j);
if (g_str_has_prefix(insn_disas, m->match_string)) {
Instruction *rec = g_new0(Instruction, 1);
@@ -169,36 +163,33 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
"len %d bytes: %ld insns\n", i, *cnt);
}
}
- } else if (do_inline) {
- g_string_append_printf(out, "insns: %" PRIu64 "\n", inline_insn_count);
} else {
- uint64_t total_insns = 0;
- for (i = 0; i < MAX_CPUS; i++) {
- InstructionCount *c = &counts[i];
- if (c->insn_count) {
- g_string_append_printf(out, "cpu %d insns: %" PRIu64 "\n",
- i, c->insn_count);
- total_insns += c->insn_count;
- }
+ for (i = 0; i < qemu_plugin_num_vcpus(); i++) {
+ g_string_append_printf(out, "cpu %d insns: %" PRIu64 "\n",
+ i, qemu_plugin_u64_get(insn_count, i));
}
g_string_append_printf(out, "total insns: %" PRIu64 "\n",
- total_insns);
+ qemu_plugin_u64_sum(insn_count));
}
qemu_plugin_outs(out->str);
+
+ qemu_plugin_scoreboard_free(insn_count.score);
+ for (i = 0; i < matches->len; ++i) {
+ Match *m = &g_array_index(matches, Match, i);
+ g_free(m->match_string);
+ qemu_plugin_scoreboard_free(m->counts);
+ }
+ g_array_free(matches, TRUE);
+ g_array_free(sizes, TRUE);
}
/* Add a match to the array of matches */
static void parse_match(char *match)
{
- Match new_match = { .match_string = match };
- int i;
- for (i = 0; i < MAX_CPUS; i++) {
- new_match.history[i] = g_ptr_array_new();
- }
- if (!matches) {
- matches = g_array_new(false, true, sizeof(Match));
- }
+ Match new_match = {
+ .match_string = g_strdup(match),
+ .counts = qemu_plugin_scoreboard_new(sizeof(MatchCount)) };
g_array_append_val(matches, new_match);
}
@@ -206,6 +197,10 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
const qemu_info_t *info,
int argc, char **argv)
{
+ matches = g_array_new(false, true, sizeof(Match));
+ /* null terminated so 0 is not a special case */
+ sizes = g_array_new(true, true, sizeof(unsigned long));
+
for (int i = 0; i < argc; i++) {
char *opt = argv[i];
g_auto(GStrv) tokens = g_strsplit(opt, "=", 2);
@@ -227,9 +222,8 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
}
}
- if (do_size) {
- sizes = g_array_new(true, true, sizeof(unsigned long));
- }
+ insn_count = qemu_plugin_scoreboard_u64(
+ qemu_plugin_scoreboard_new(sizeof(uint64_t)));
/* Register init, translation block and exit callbacks */
qemu_plugin_register_vcpu_init_cb(id, vcpu_init);
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 08/12] tests/plugin/bb: migrate to new per_vcpu API
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
` (6 preceding siblings ...)
2024-02-29 5:25 ` [PATCH v6 07/12] tests/plugin/insn: " Pierrick Bouvier
@ 2024-02-29 5:25 ` Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 09/12] contrib/plugins/hotblocks: " Pierrick Bouvier
` (3 subsequent siblings)
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:25 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss, Luc Michel
Reviewed-by: Luc Michel <luc.michel@amd.com>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
tests/plugin/bb.c | 63 +++++++++++++++++++----------------------------
1 file changed, 26 insertions(+), 37 deletions(-)
diff --git a/tests/plugin/bb.c b/tests/plugin/bb.c
index df50d1fd3bc..36776dee1e1 100644
--- a/tests/plugin/bb.c
+++ b/tests/plugin/bb.c
@@ -17,27 +17,25 @@
QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
typedef struct {
- GMutex lock;
- int index;
uint64_t bb_count;
uint64_t insn_count;
} CPUCount;
-/* Used by the inline & linux-user counts */
+static struct qemu_plugin_scoreboard *counts;
+static qemu_plugin_u64 bb_count;
+static qemu_plugin_u64 insn_count;
+
static bool do_inline;
-static CPUCount inline_count;
-
/* Dump running CPU total on idle? */
static bool idle_report;
-static GPtrArray *counts;
-static int max_cpus;
-static void gen_one_cpu_report(CPUCount *count, GString *report)
+static void gen_one_cpu_report(CPUCount *count, GString *report,
+ unsigned int cpu_index)
{
if (count->bb_count) {
g_string_append_printf(report, "CPU%d: "
"bb's: %" PRIu64", insns: %" PRIu64 "\n",
- count->index,
+ cpu_index,
count->bb_count, count->insn_count);
}
}
@@ -46,20 +44,23 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
{
g_autoptr(GString) report = g_string_new("");
- if (do_inline || !max_cpus) {
- g_string_printf(report, "bb's: %" PRIu64", insns: %" PRIu64 "\n",
- inline_count.bb_count, inline_count.insn_count);
- } else {
- g_ptr_array_foreach(counts, (GFunc) gen_one_cpu_report, report);
+ for (int i = 0; i < qemu_plugin_num_vcpus(); ++i) {
+ CPUCount *count = qemu_plugin_scoreboard_find(counts, i);
+ gen_one_cpu_report(count, report, i);
}
+ g_string_append_printf(report, "Total: "
+ "bb's: %" PRIu64", insns: %" PRIu64 "\n",
+ qemu_plugin_u64_sum(bb_count),
+ qemu_plugin_u64_sum(insn_count));
qemu_plugin_outs(report->str);
+ qemu_plugin_scoreboard_free(counts);
}
static void vcpu_idle(qemu_plugin_id_t id, unsigned int cpu_index)
{
- CPUCount *count = g_ptr_array_index(counts, cpu_index);
+ CPUCount *count = qemu_plugin_scoreboard_find(counts, cpu_index);
g_autoptr(GString) report = g_string_new("");
- gen_one_cpu_report(count, report);
+ gen_one_cpu_report(count, report, cpu_index);
if (report->len > 0) {
g_string_prepend(report, "Idling ");
@@ -69,14 +70,11 @@ static void vcpu_idle(qemu_plugin_id_t id, unsigned int cpu_index)
static void vcpu_tb_exec(unsigned int cpu_index, void *udata)
{
- CPUCount *count = max_cpus ?
- g_ptr_array_index(counts, cpu_index) : &inline_count;
+ CPUCount *count = qemu_plugin_scoreboard_find(counts, cpu_index);
uintptr_t n_insns = (uintptr_t)udata;
- g_mutex_lock(&count->lock);
count->insn_count += n_insns;
count->bb_count++;
- g_mutex_unlock(&count->lock);
}
static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
@@ -84,11 +82,10 @@ static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
size_t n_insns = qemu_plugin_tb_n_insns(tb);
if (do_inline) {
- qemu_plugin_register_vcpu_tb_exec_inline(tb, QEMU_PLUGIN_INLINE_ADD_U64,
- &inline_count.bb_count, 1);
- qemu_plugin_register_vcpu_tb_exec_inline(tb, QEMU_PLUGIN_INLINE_ADD_U64,
- &inline_count.insn_count,
- n_insns);
+ qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu(
+ tb, QEMU_PLUGIN_INLINE_ADD_U64, bb_count, 1);
+ qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu(
+ tb, QEMU_PLUGIN_INLINE_ADD_U64, insn_count, n_insns);
} else {
qemu_plugin_register_vcpu_tb_exec_cb(tb, vcpu_tb_exec,
QEMU_PLUGIN_CB_NO_REGS,
@@ -121,18 +118,10 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
}
}
- if (info->system_emulation && !do_inline) {
- max_cpus = info->system.max_vcpus;
- counts = g_ptr_array_new();
- for (i = 0; i < max_cpus; i++) {
- CPUCount *count = g_new0(CPUCount, 1);
- g_mutex_init(&count->lock);
- count->index = i;
- g_ptr_array_add(counts, count);
- }
- } else if (!do_inline) {
- g_mutex_init(&inline_count.lock);
- }
+ counts = qemu_plugin_scoreboard_new(sizeof(CPUCount));
+ bb_count = qemu_plugin_scoreboard_u64_in_struct(counts, CPUCount, bb_count);
+ insn_count = qemu_plugin_scoreboard_u64_in_struct(
+ counts, CPUCount, insn_count);
if (idle_report) {
qemu_plugin_register_vcpu_idle_cb(id, vcpu_idle);
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 09/12] contrib/plugins/hotblocks: migrate to new per_vcpu API
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
` (7 preceding siblings ...)
2024-02-29 5:25 ` [PATCH v6 08/12] tests/plugin/bb: " Pierrick Bouvier
@ 2024-02-29 5:25 ` Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 10/12] contrib/plugins/howvec: " Pierrick Bouvier
` (2 subsequent siblings)
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:25 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
contrib/plugins/hotblocks.c | 50 ++++++++++++++++++++++---------------
1 file changed, 30 insertions(+), 20 deletions(-)
diff --git a/contrib/plugins/hotblocks.c b/contrib/plugins/hotblocks.c
index 4de1b134944..02bc5078bdd 100644
--- a/contrib/plugins/hotblocks.c
+++ b/contrib/plugins/hotblocks.c
@@ -34,8 +34,8 @@ static guint64 limit = 20;
*/
typedef struct {
uint64_t start_addr;
- uint64_t exec_count;
- int trans_count;
+ struct qemu_plugin_scoreboard *exec_count;
+ int trans_count;
unsigned long insns;
} ExecCount;
@@ -43,7 +43,17 @@ static gint cmp_exec_count(gconstpointer a, gconstpointer b)
{
ExecCount *ea = (ExecCount *) a;
ExecCount *eb = (ExecCount *) b;
- return ea->exec_count > eb->exec_count ? -1 : 1;
+ uint64_t count_a =
+ qemu_plugin_u64_sum(qemu_plugin_scoreboard_u64(ea->exec_count));
+ uint64_t count_b =
+ qemu_plugin_u64_sum(qemu_plugin_scoreboard_u64(eb->exec_count));
+ return count_a > count_b ? -1 : 1;
+}
+
+static void exec_count_free(gpointer key, gpointer value, gpointer user_data)
+{
+ ExecCount *cnt = value;
+ qemu_plugin_scoreboard_free(cnt->exec_count);
}
static void plugin_exit(qemu_plugin_id_t id, void *p)
@@ -52,7 +62,6 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
GList *counts, *it;
int i;
- g_mutex_lock(&lock);
g_string_append_printf(report, "%d entries in the hash table\n",
g_hash_table_size(hotblocks));
counts = g_hash_table_get_values(hotblocks);
@@ -63,16 +72,21 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
for (i = 0; i < limit && it->next; i++, it = it->next) {
ExecCount *rec = (ExecCount *) it->data;
- g_string_append_printf(report, "0x%016"PRIx64", %d, %ld, %"PRId64"\n",
- rec->start_addr, rec->trans_count,
- rec->insns, rec->exec_count);
+ g_string_append_printf(
+ report, "0x%016"PRIx64", %d, %ld, %"PRId64"\n",
+ rec->start_addr, rec->trans_count,
+ rec->insns,
+ qemu_plugin_u64_sum(
+ qemu_plugin_scoreboard_u64(rec->exec_count)));
}
g_list_free(it);
}
- g_mutex_unlock(&lock);
qemu_plugin_outs(report->str);
+
+ g_hash_table_foreach(hotblocks, exec_count_free, NULL);
+ g_hash_table_destroy(hotblocks);
}
static void plugin_init(void)
@@ -82,15 +96,9 @@ static void plugin_init(void)
static void vcpu_tb_exec(unsigned int cpu_index, void *udata)
{
- ExecCount *cnt;
- uint64_t hash = (uint64_t) udata;
-
- g_mutex_lock(&lock);
- cnt = (ExecCount *) g_hash_table_lookup(hotblocks, (gconstpointer) hash);
- /* should always succeed */
- g_assert(cnt);
- cnt->exec_count++;
- g_mutex_unlock(&lock);
+ ExecCount *cnt = (ExecCount *)udata;
+ qemu_plugin_u64_add(qemu_plugin_scoreboard_u64(cnt->exec_count),
+ cpu_index, 1);
}
/*
@@ -114,18 +122,20 @@ static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
cnt->start_addr = pc;
cnt->trans_count = 1;
cnt->insns = insns;
+ cnt->exec_count = qemu_plugin_scoreboard_new(sizeof(uint64_t));
g_hash_table_insert(hotblocks, (gpointer) hash, (gpointer) cnt);
}
g_mutex_unlock(&lock);
if (do_inline) {
- qemu_plugin_register_vcpu_tb_exec_inline(tb, QEMU_PLUGIN_INLINE_ADD_U64,
- &cnt->exec_count, 1);
+ qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu(
+ tb, QEMU_PLUGIN_INLINE_ADD_U64,
+ qemu_plugin_scoreboard_u64(cnt->exec_count), 1);
} else {
qemu_plugin_register_vcpu_tb_exec_cb(tb, vcpu_tb_exec,
QEMU_PLUGIN_CB_NO_REGS,
- (void *)hash);
+ (void *)cnt);
}
}
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 10/12] contrib/plugins/howvec: migrate to new per_vcpu API
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
` (8 preceding siblings ...)
2024-02-29 5:25 ` [PATCH v6 09/12] contrib/plugins/hotblocks: " Pierrick Bouvier
@ 2024-02-29 5:25 ` Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 11/12] plugins: remove non per_vcpu inline operation from API Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 12/12] plugins: cleanup codepath for previous inline operation Pierrick Bouvier
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:25 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
contrib/plugins/howvec.c | 53 ++++++++++++++++++++++++++++------------
1 file changed, 38 insertions(+), 15 deletions(-)
diff --git a/contrib/plugins/howvec.c b/contrib/plugins/howvec.c
index 644a7856bb2..2d10c87e0fb 100644
--- a/contrib/plugins/howvec.c
+++ b/contrib/plugins/howvec.c
@@ -43,13 +43,13 @@ typedef struct {
uint32_t mask;
uint32_t pattern;
CountType what;
- uint64_t count;
+ qemu_plugin_u64 count;
} InsnClassExecCount;
typedef struct {
char *insn;
uint32_t opcode;
- uint64_t count;
+ qemu_plugin_u64 count;
InsnClassExecCount *class;
} InsnExecCount;
@@ -159,7 +159,9 @@ static gint cmp_exec_count(gconstpointer a, gconstpointer b)
{
InsnExecCount *ea = (InsnExecCount *) a;
InsnExecCount *eb = (InsnExecCount *) b;
- return ea->count > eb->count ? -1 : 1;
+ uint64_t count_a = qemu_plugin_u64_sum(ea->count);
+ uint64_t count_b = qemu_plugin_u64_sum(eb->count);
+ return count_a > count_b ? -1 : 1;
}
static void free_record(gpointer data)
@@ -167,12 +169,14 @@ static void free_record(gpointer data)
InsnExecCount *rec = (InsnExecCount *) data;
g_free(rec->insn);
g_free(rec);
+ qemu_plugin_scoreboard_free(rec->count.score);
}
static void plugin_exit(qemu_plugin_id_t id, void *p)
{
g_autoptr(GString) report = g_string_new("Instruction Classes:\n");
int i;
+ uint64_t total_count;
GList *counts;
InsnClassExecCount *class = NULL;
@@ -180,11 +184,12 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
class = &class_table[i];
switch (class->what) {
case COUNT_CLASS:
- if (class->count || verbose) {
+ total_count = qemu_plugin_u64_sum(class->count);
+ if (total_count || verbose) {
g_string_append_printf(report,
"Class: %-24s\t(%" PRId64 " hits)\n",
class->class,
- class->count);
+ total_count);
}
break;
case COUNT_INDIVIDUAL:
@@ -212,7 +217,7 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
"Instr: %-24s\t(%" PRId64 " hits)"
"\t(op=0x%08x/%s)\n",
rec->insn,
- rec->count,
+ qemu_plugin_u64_sum(rec->count),
rec->opcode,
rec->class ?
rec->class->class : "un-categorised");
@@ -221,6 +226,12 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
}
g_hash_table_destroy(insns);
+ for (i = 0; i < ARRAY_SIZE(class_tables); i++) {
+ for (int j = 0; j < class_tables[i].table_sz; ++j) {
+ qemu_plugin_scoreboard_free(class_tables[i].table[j].count.score);
+ }
+ }
+
qemu_plugin_outs(report->str);
}
@@ -232,11 +243,12 @@ static void plugin_init(void)
static void vcpu_insn_exec_before(unsigned int cpu_index, void *udata)
{
- uint64_t *count = (uint64_t *) udata;
- (*count)++;
+ struct qemu_plugin_scoreboard *score = udata;
+ qemu_plugin_u64_add(qemu_plugin_scoreboard_u64(score), cpu_index, 1);
}
-static uint64_t *find_counter(struct qemu_plugin_insn *insn)
+static struct qemu_plugin_scoreboard *find_counter(
+ struct qemu_plugin_insn *insn)
{
int i;
uint64_t *cnt = NULL;
@@ -265,7 +277,7 @@ static uint64_t *find_counter(struct qemu_plugin_insn *insn)
case COUNT_NONE:
return NULL;
case COUNT_CLASS:
- return &class->count;
+ return class->count.score;
case COUNT_INDIVIDUAL:
{
InsnExecCount *icount;
@@ -279,13 +291,16 @@ static uint64_t *find_counter(struct qemu_plugin_insn *insn)
icount->opcode = opcode;
icount->insn = qemu_plugin_insn_disas(insn);
icount->class = class;
+ struct qemu_plugin_scoreboard *score =
+ qemu_plugin_scoreboard_new(sizeof(uint64_t));
+ icount->count = qemu_plugin_scoreboard_u64(score);
g_hash_table_insert(insns, GUINT_TO_POINTER(opcode),
(gpointer) icount);
}
g_mutex_unlock(&lock);
- return &icount->count;
+ return icount->count.score;
}
default:
g_assert_not_reached();
@@ -300,14 +315,14 @@ static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
size_t i;
for (i = 0; i < n; i++) {
- uint64_t *cnt;
struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, i);
- cnt = find_counter(insn);
+ struct qemu_plugin_scoreboard *cnt = find_counter(insn);
if (cnt) {
if (do_inline) {
- qemu_plugin_register_vcpu_insn_exec_inline(
- insn, QEMU_PLUGIN_INLINE_ADD_U64, cnt, 1);
+ qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu(
+ insn, QEMU_PLUGIN_INLINE_ADD_U64,
+ qemu_plugin_scoreboard_u64(cnt), 1);
} else {
qemu_plugin_register_vcpu_insn_exec_cb(
insn, vcpu_insn_exec_before, QEMU_PLUGIN_CB_NO_REGS, cnt);
@@ -322,6 +337,14 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
{
int i;
+ for (i = 0; i < ARRAY_SIZE(class_tables); i++) {
+ for (int j = 0; j < class_tables[i].table_sz; ++j) {
+ struct qemu_plugin_scoreboard *score =
+ qemu_plugin_scoreboard_new(sizeof(uint64_t));
+ class_tables[i].table[j].count = qemu_plugin_scoreboard_u64(score);
+ }
+ }
+
/* Select a class table appropriate to the guest architecture */
for (i = 0; i < ARRAY_SIZE(class_tables); i++) {
ClassSelector *entry = &class_tables[i];
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 11/12] plugins: remove non per_vcpu inline operation from API
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
` (9 preceding siblings ...)
2024-02-29 5:25 ` [PATCH v6 10/12] contrib/plugins/howvec: " Pierrick Bouvier
@ 2024-02-29 5:25 ` Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 12/12] plugins: cleanup codepath for previous inline operation Pierrick Bouvier
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:25 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
Now we have a thread-safe equivalent of inline operation, and that all
plugins were changed to use it, there is no point to keep the old API.
In more, it will help when we implement more functionality (conditional
callbacks), as we can assume that we operate on a scoreboard.
API version bump was already done as part of this series.
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
include/qemu/qemu-plugin.h | 58 ++++--------------------------------
plugins/api.c | 29 ------------------
plugins/qemu-plugins.symbols | 3 --
3 files changed, 5 insertions(+), 85 deletions(-)
diff --git a/include/qemu/qemu-plugin.h b/include/qemu/qemu-plugin.h
index 6bbad068c01..4fc6c3739b2 100644
--- a/include/qemu/qemu-plugin.h
+++ b/include/qemu/qemu-plugin.h
@@ -52,7 +52,11 @@ typedef uint64_t qemu_plugin_id_t;
* The plugins export the API they were built against by exposing the
* symbol qemu_plugin_version which can be checked.
*
- * version 2: removed qemu_plugin_n_vcpus and qemu_plugin_n_max_vcpus
+ * version 2:
+ * - removed qemu_plugin_n_vcpus and qemu_plugin_n_max_vcpus
+ * - Remove qemu_plugin_register_vcpu_{tb, insn, mem}_exec_inline.
+ * Those functions are replaced by *_per_vcpu variants, which guarantee
+ * thread-safety for operations.
*/
extern QEMU_PLUGIN_EXPORT int qemu_plugin_version;
@@ -309,25 +313,6 @@ enum qemu_plugin_op {
QEMU_PLUGIN_INLINE_ADD_U64,
};
-/**
- * qemu_plugin_register_vcpu_tb_exec_inline() - execution inline op
- * @tb: the opaque qemu_plugin_tb handle for the translation
- * @op: the type of qemu_plugin_op (e.g. ADD_U64)
- * @ptr: the target memory location for the op
- * @imm: the op data (e.g. 1)
- *
- * Insert an inline op to every time a translated unit executes.
- * Useful if you just want to increment a single counter somewhere in
- * memory.
- *
- * Note: ops are not atomic so in multi-threaded/multi-smp situations
- * you will get inexact results.
- */
-QEMU_PLUGIN_API
-void qemu_plugin_register_vcpu_tb_exec_inline(struct qemu_plugin_tb *tb,
- enum qemu_plugin_op op,
- void *ptr, uint64_t imm);
-
/**
* qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu() - execution inline op
* @tb: the opaque qemu_plugin_tb handle for the translation
@@ -359,21 +344,6 @@ void qemu_plugin_register_vcpu_insn_exec_cb(struct qemu_plugin_insn *insn,
enum qemu_plugin_cb_flags flags,
void *userdata);
-/**
- * qemu_plugin_register_vcpu_insn_exec_inline() - insn execution inline op
- * @insn: the opaque qemu_plugin_insn handle for an instruction
- * @op: the type of qemu_plugin_op (e.g. ADD_U64)
- * @ptr: the target memory location for the op
- * @imm: the op data (e.g. 1)
- *
- * Insert an inline op to every time an instruction executes. Useful
- * if you just want to increment a single counter somewhere in memory.
- */
-QEMU_PLUGIN_API
-void qemu_plugin_register_vcpu_insn_exec_inline(struct qemu_plugin_insn *insn,
- enum qemu_plugin_op op,
- void *ptr, uint64_t imm);
-
/**
* qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu() - insn exec inline op
* @insn: the opaque qemu_plugin_insn handle for an instruction
@@ -597,24 +567,6 @@ void qemu_plugin_register_vcpu_mem_cb(struct qemu_plugin_insn *insn,
enum qemu_plugin_mem_rw rw,
void *userdata);
-/**
- * qemu_plugin_register_vcpu_mem_inline() - register an inline op to any memory access
- * @insn: handle for instruction to instrument
- * @rw: apply to reads, writes or both
- * @op: the op, of type qemu_plugin_op
- * @ptr: pointer memory for the op
- * @imm: immediate data for @op
- *
- * This registers a inline op every memory access generated by the
- * instruction. This provides for a lightweight but not thread-safe
- * way of counting the number of operations done.
- */
-QEMU_PLUGIN_API
-void qemu_plugin_register_vcpu_mem_inline(struct qemu_plugin_insn *insn,
- enum qemu_plugin_mem_rw rw,
- enum qemu_plugin_op op, void *ptr,
- uint64_t imm);
-
/**
* qemu_plugin_register_vcpu_mem_inline_per_vcpu() - inline op for mem access
* @insn: handle for instruction to instrument
diff --git a/plugins/api.c b/plugins/api.c
index ac3982c6636..58e851effdb 100644
--- a/plugins/api.c
+++ b/plugins/api.c
@@ -101,16 +101,6 @@ void qemu_plugin_register_vcpu_tb_exec_cb(struct qemu_plugin_tb *tb,
}
}
-void qemu_plugin_register_vcpu_tb_exec_inline(struct qemu_plugin_tb *tb,
- enum qemu_plugin_op op,
- void *ptr, uint64_t imm)
-{
- if (!tb->mem_only) {
- plugin_register_inline_op(&tb->cbs[PLUGIN_CB_INLINE],
- 0, op, ptr, imm);
- }
-}
-
void qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu(
struct qemu_plugin_tb *tb,
enum qemu_plugin_op op,
@@ -138,16 +128,6 @@ void qemu_plugin_register_vcpu_insn_exec_cb(struct qemu_plugin_insn *insn,
}
}
-void qemu_plugin_register_vcpu_insn_exec_inline(struct qemu_plugin_insn *insn,
- enum qemu_plugin_op op,
- void *ptr, uint64_t imm)
-{
- if (!insn->mem_only) {
- plugin_register_inline_op(&insn->cbs[PLUGIN_CB_INSN][PLUGIN_CB_INLINE],
- 0, op, ptr, imm);
- }
-}
-
void qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu(
struct qemu_plugin_insn *insn,
enum qemu_plugin_op op,
@@ -175,15 +155,6 @@ void qemu_plugin_register_vcpu_mem_cb(struct qemu_plugin_insn *insn,
cb, flags, rw, udata);
}
-void qemu_plugin_register_vcpu_mem_inline(struct qemu_plugin_insn *insn,
- enum qemu_plugin_mem_rw rw,
- enum qemu_plugin_op op, void *ptr,
- uint64_t imm)
-{
- plugin_register_inline_op(&insn->cbs[PLUGIN_CB_MEM][PLUGIN_CB_INLINE],
- rw, op, ptr, imm);
-}
-
void qemu_plugin_register_vcpu_mem_inline_per_vcpu(
struct qemu_plugin_insn *insn,
enum qemu_plugin_mem_rw rw,
diff --git a/plugins/qemu-plugins.symbols b/plugins/qemu-plugins.symbols
index 0d8141b85f1..a9fac056c7f 100644
--- a/plugins/qemu-plugins.symbols
+++ b/plugins/qemu-plugins.symbols
@@ -27,16 +27,13 @@
qemu_plugin_register_vcpu_idle_cb;
qemu_plugin_register_vcpu_init_cb;
qemu_plugin_register_vcpu_insn_exec_cb;
- qemu_plugin_register_vcpu_insn_exec_inline;
qemu_plugin_register_vcpu_insn_exec_inline_per_vcpu;
qemu_plugin_register_vcpu_mem_cb;
- qemu_plugin_register_vcpu_mem_inline;
qemu_plugin_register_vcpu_mem_inline_per_vcpu;
qemu_plugin_register_vcpu_resume_cb;
qemu_plugin_register_vcpu_syscall_cb;
qemu_plugin_register_vcpu_syscall_ret_cb;
qemu_plugin_register_vcpu_tb_exec_cb;
- qemu_plugin_register_vcpu_tb_exec_inline;
qemu_plugin_register_vcpu_tb_exec_inline_per_vcpu;
qemu_plugin_register_vcpu_tb_trans_cb;
qemu_plugin_reset;
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* [PATCH v6 12/12] plugins: cleanup codepath for previous inline operation
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
` (10 preceding siblings ...)
2024-02-29 5:25 ` [PATCH v6 11/12] plugins: remove non per_vcpu inline operation from API Pierrick Bouvier
@ 2024-02-29 5:25 ` Pierrick Bouvier
11 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-02-29 5:25 UTC (permalink / raw)
To: qemu-devel
Cc: Alex Bennée, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Pierrick Bouvier,
Richard Henderson, Marcel Apfelbaum, Paolo Bonzini,
Alexandre Iooss
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
plugins/plugin.h | 5 -----
accel/tcg/plugin-gen.c | 13 ++++---------
plugins/core.c | 29 ++++-------------------------
3 files changed, 8 insertions(+), 39 deletions(-)
diff --git a/plugins/plugin.h b/plugins/plugin.h
index f6fa10a0f56..7c34f23cfcb 100644
--- a/plugins/plugin.h
+++ b/plugins/plugin.h
@@ -68,11 +68,6 @@ struct qemu_plugin_ctx {
struct qemu_plugin_ctx *plugin_id_to_ctx_locked(qemu_plugin_id_t id);
-void plugin_register_inline_op(GArray **arr,
- enum qemu_plugin_mem_rw rw,
- enum qemu_plugin_op op, void *ptr,
- uint64_t imm);
-
void plugin_register_inline_op_on_entry(GArray **arr,
enum qemu_plugin_mem_rw rw,
enum qemu_plugin_op op,
diff --git a/accel/tcg/plugin-gen.c b/accel/tcg/plugin-gen.c
index 47e05ec6347..8028786c7bb 100644
--- a/accel/tcg/plugin-gen.c
+++ b/accel/tcg/plugin-gen.c
@@ -440,15 +440,10 @@ static TCGOp *append_inline_cb(const struct qemu_plugin_dyn_cb *cb,
TCGOp *begin_op, TCGOp *op,
int *unused)
{
- char *ptr = cb->userp;
- size_t elem_size = 0;
- size_t offset = 0;
- if (!ptr) {
- /* use inline entry */
- ptr = cb->inline_insn.entry.score->data->data;
- elem_size = g_array_get_element_size(cb->inline_insn.entry.score->data);
- offset = cb->inline_insn.entry.offset;
- }
+ char *ptr = cb->inline_insn.entry.score->data->data;
+ size_t elem_size = g_array_get_element_size(
+ cb->inline_insn.entry.score->data);
+ size_t offset = cb->inline_insn.entry.offset;
op = copy_ld_i32(&begin_op, op);
op = copy_mul_i32(&begin_op, op, elem_size);
diff --git a/plugins/core.c b/plugins/core.c
index 7852590da88..11ca20e6267 100644
--- a/plugins/core.c
+++ b/plugins/core.c
@@ -316,22 +316,6 @@ static struct qemu_plugin_dyn_cb *plugin_get_dyn_cb(GArray **arr)
return &g_array_index(cbs, struct qemu_plugin_dyn_cb, cbs->len - 1);
}
-void plugin_register_inline_op(GArray **arr,
- enum qemu_plugin_mem_rw rw,
- enum qemu_plugin_op op,
- void *ptr,
- uint64_t imm)
-{
- struct qemu_plugin_dyn_cb *dyn_cb;
-
- dyn_cb = plugin_get_dyn_cb(arr);
- dyn_cb->userp = ptr;
- dyn_cb->type = PLUGIN_CB_INLINE;
- dyn_cb->rw = rw;
- dyn_cb->inline_insn.op = op;
- dyn_cb->inline_insn.imm = imm;
-}
-
void plugin_register_inline_op_on_entry(GArray **arr,
enum qemu_plugin_mem_rw rw,
enum qemu_plugin_op op,
@@ -494,15 +478,10 @@ void qemu_plugin_flush_cb(void)
void exec_inline_op(struct qemu_plugin_dyn_cb *cb, int cpu_index)
{
- char *ptr = cb->userp;
- size_t elem_size = 0;
- size_t offset = 0;
- if (!ptr) {
- /* use inline entry */
- ptr = cb->inline_insn.entry.score->data->data;
- elem_size = g_array_get_element_size(cb->inline_insn.entry.score->data);
- offset = cb->inline_insn.entry.offset;
- }
+ char *ptr = cb->inline_insn.entry.score->data->data;
+ size_t elem_size = g_array_get_element_size(
+ cb->inline_insn.entry.score->data);
+ size_t offset = cb->inline_insn.entry.offset;
uint64_t *val = (uint64_t *)(ptr + offset + cpu_index * elem_size);
switch (cb->inline_insn.op) {
--
2.43.0
^ permalink raw reply related [flat|nested] 15+ messages in thread
* Re: [PATCH v6 06/12] tests/plugin/mem: migrate to new per_vcpu API
2024-02-29 5:25 ` [PATCH v6 06/12] tests/plugin/mem: migrate to new per_vcpu API Pierrick Bouvier
@ 2024-02-29 18:08 ` Alex Bennée
2024-03-01 9:40 ` Pierrick Bouvier
0 siblings, 1 reply; 15+ messages in thread
From: Alex Bennée @ 2024-02-29 18:08 UTC (permalink / raw)
To: Pierrick Bouvier
Cc: qemu-devel, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Richard Henderson,
Marcel Apfelbaum, Paolo Bonzini, Alexandre Iooss, Luc Michel
Pierrick Bouvier <pierrick.bouvier@linaro.org> writes:
> Reviewed-by: Luc Michel <luc.michel@amd.com>
> Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
> ---
> tests/plugin/mem.c | 46 +++++++++++++++++++++++++++++++---------------
> 1 file changed, 31 insertions(+), 15 deletions(-)
>
> diff --git a/tests/plugin/mem.c b/tests/plugin/mem.c
> index 44e91065ba7..b650dddcce1 100644
> --- a/tests/plugin/mem.c
> +++ b/tests/plugin/mem.c
> @@ -16,9 +16,14 @@
>
> QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
>
> -static uint64_t inline_mem_count;
> -static uint64_t cb_mem_count;
> -static uint64_t io_count;
> +typedef struct {
> + uint64_t mem_count;
> + uint64_t io_count;
> +} CPUCount;
> +
> +static struct qemu_plugin_scoreboard *counts;
> +static qemu_plugin_u64 mem_count;
> +static qemu_plugin_u64 io_count;
> static bool do_inline, do_callback;
> static bool do_haddr;
> static enum qemu_plugin_mem_rw rw = QEMU_PLUGIN_MEM_RW;
> @@ -27,16 +32,16 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
> {
> g_autoptr(GString) out = g_string_new("");
>
> - if (do_inline) {
> - g_string_printf(out, "inline mem accesses: %" PRIu64 "\n", inline_mem_count);
> - }
> - if (do_callback) {
> - g_string_append_printf(out, "callback mem accesses: %" PRIu64 "\n", cb_mem_count);
> + if (do_inline || do_callback) {
> + g_string_printf(out, "mem accesses: %" PRIu64 "\n",
> + qemu_plugin_u64_sum(mem_count));
> }
> if (do_haddr) {
> - g_string_append_printf(out, "io accesses: %" PRIu64 "\n", io_count);
> + g_string_append_printf(out, "io accesses: %" PRIu64 "\n",
> + qemu_plugin_u64_sum(io_count));
> }
> qemu_plugin_outs(out->str);
> + qemu_plugin_scoreboard_free(counts);
> }
>
> static void vcpu_mem(unsigned int cpu_index, qemu_plugin_meminfo_t meminfo,
> @@ -46,12 +51,12 @@ static void vcpu_mem(unsigned int cpu_index, qemu_plugin_meminfo_t meminfo,
> struct qemu_plugin_hwaddr *hwaddr;
> hwaddr = qemu_plugin_get_hwaddr(meminfo, vaddr);
> if (qemu_plugin_hwaddr_is_io(hwaddr)) {
> - io_count++;
> + qemu_plugin_u64_add(io_count, cpu_index, 1);
> } else {
> - cb_mem_count++;
> + qemu_plugin_u64_add(mem_count, cpu_index, 1);
> }
> } else {
> - cb_mem_count++;
> + qemu_plugin_u64_add(mem_count, cpu_index, 1);
> }
> }
>
> @@ -64,9 +69,10 @@ static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
> struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, i);
>
> if (do_inline) {
> - qemu_plugin_register_vcpu_mem_inline(insn, rw,
> - QEMU_PLUGIN_INLINE_ADD_U64,
> - &inline_mem_count, 1);
> + qemu_plugin_register_vcpu_mem_inline_per_vcpu(
> + insn, rw,
> + QEMU_PLUGIN_INLINE_ADD_U64,
> + mem_count, 1);
> }
> if (do_callback) {
> qemu_plugin_register_vcpu_mem_cb(insn, vcpu_mem,
> @@ -117,6 +123,16 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
> }
> }
>
> + if (do_inline && do_callback) {
> + fprintf(stderr,
> + "can't enable inline and callback counting at the same time\n");
> + return -1;
> + }
> +
> + counts = qemu_plugin_scoreboard_new(sizeof(CPUCount));
> + mem_count = qemu_plugin_scoreboard_u64_in_struct(
> + counts, CPUCount, mem_count);
> + io_count = qemu_plugin_scoreboard_u64_in_struct(counts, CPUCount, io_count);
> qemu_plugin_register_vcpu_tb_trans_cb(id, vcpu_tb_trans);
> qemu_plugin_register_atexit_cb(id, plugin_exit, NULL);
> return 0;
You need the following to keep check-tcg working:
modified tests/tcg/Makefile.target
@@ -168,7 +168,7 @@ RUN_TESTS+=$(EXTRA_RUNS)
# Some plugins need additional arguments above the default to fully
# exercise things. We can define them on a per-test basis here.
-run-plugin-%-with-libmem.so: PLUGIN_ARGS=$(COMMA)inline=true$(COMMA)callback=true
+run-plugin-%-with-libmem.so: PLUGIN_ARGS=$(COMMA)inline=true
ifeq ($(filter %-softmmu, $(TARGET)),)
run-%: %
--
Alex Bennée
Virtualisation Tech Lead @ Linaro
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH v6 06/12] tests/plugin/mem: migrate to new per_vcpu API
2024-02-29 18:08 ` Alex Bennée
@ 2024-03-01 9:40 ` Pierrick Bouvier
0 siblings, 0 replies; 15+ messages in thread
From: Pierrick Bouvier @ 2024-03-01 9:40 UTC (permalink / raw)
To: Alex Bennée
Cc: qemu-devel, Mahmoud Mandour, Eduardo Habkost,
Philippe Mathieu-Daudé, Yanan Wang, Richard Henderson,
Marcel Apfelbaum, Paolo Bonzini, Alexandre Iooss, Luc Michel
On 2/29/24 10:08 PM, Alex Bennée wrote:
> Pierrick Bouvier <pierrick.bouvier@linaro.org> writes:
>
>> Reviewed-by: Luc Michel <luc.michel@amd.com>
>> Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
>> ---
>> tests/plugin/mem.c | 46 +++++++++++++++++++++++++++++++---------------
>> 1 file changed, 31 insertions(+), 15 deletions(-)
>>
>> diff --git a/tests/plugin/mem.c b/tests/plugin/mem.c
>> index 44e91065ba7..b650dddcce1 100644
>> --- a/tests/plugin/mem.c
>> +++ b/tests/plugin/mem.c
>> @@ -16,9 +16,14 @@
>>
>> QEMU_PLUGIN_EXPORT int qemu_plugin_version = QEMU_PLUGIN_VERSION;
>>
>> -static uint64_t inline_mem_count;
>> -static uint64_t cb_mem_count;
>> -static uint64_t io_count;
>> +typedef struct {
>> + uint64_t mem_count;
>> + uint64_t io_count;
>> +} CPUCount;
>> +
>> +static struct qemu_plugin_scoreboard *counts;
>> +static qemu_plugin_u64 mem_count;
>> +static qemu_plugin_u64 io_count;
>> static bool do_inline, do_callback;
>> static bool do_haddr;
>> static enum qemu_plugin_mem_rw rw = QEMU_PLUGIN_MEM_RW;
>> @@ -27,16 +32,16 @@ static void plugin_exit(qemu_plugin_id_t id, void *p)
>> {
>> g_autoptr(GString) out = g_string_new("");
>>
>> - if (do_inline) {
>> - g_string_printf(out, "inline mem accesses: %" PRIu64 "\n", inline_mem_count);
>> - }
>> - if (do_callback) {
>> - g_string_append_printf(out, "callback mem accesses: %" PRIu64 "\n", cb_mem_count);
>> + if (do_inline || do_callback) {
>> + g_string_printf(out, "mem accesses: %" PRIu64 "\n",
>> + qemu_plugin_u64_sum(mem_count));
>> }
>> if (do_haddr) {
>> - g_string_append_printf(out, "io accesses: %" PRIu64 "\n", io_count);
>> + g_string_append_printf(out, "io accesses: %" PRIu64 "\n",
>> + qemu_plugin_u64_sum(io_count));
>> }
>> qemu_plugin_outs(out->str);
>> + qemu_plugin_scoreboard_free(counts);
>> }
>>
>> static void vcpu_mem(unsigned int cpu_index, qemu_plugin_meminfo_t meminfo,
>> @@ -46,12 +51,12 @@ static void vcpu_mem(unsigned int cpu_index, qemu_plugin_meminfo_t meminfo,
>> struct qemu_plugin_hwaddr *hwaddr;
>> hwaddr = qemu_plugin_get_hwaddr(meminfo, vaddr);
>> if (qemu_plugin_hwaddr_is_io(hwaddr)) {
>> - io_count++;
>> + qemu_plugin_u64_add(io_count, cpu_index, 1);
>> } else {
>> - cb_mem_count++;
>> + qemu_plugin_u64_add(mem_count, cpu_index, 1);
>> }
>> } else {
>> - cb_mem_count++;
>> + qemu_plugin_u64_add(mem_count, cpu_index, 1);
>> }
>> }
>>
>> @@ -64,9 +69,10 @@ static void vcpu_tb_trans(qemu_plugin_id_t id, struct qemu_plugin_tb *tb)
>> struct qemu_plugin_insn *insn = qemu_plugin_tb_get_insn(tb, i);
>>
>> if (do_inline) {
>> - qemu_plugin_register_vcpu_mem_inline(insn, rw,
>> - QEMU_PLUGIN_INLINE_ADD_U64,
>> - &inline_mem_count, 1);
>> + qemu_plugin_register_vcpu_mem_inline_per_vcpu(
>> + insn, rw,
>> + QEMU_PLUGIN_INLINE_ADD_U64,
>> + mem_count, 1);
>> }
>> if (do_callback) {
>> qemu_plugin_register_vcpu_mem_cb(insn, vcpu_mem,
>> @@ -117,6 +123,16 @@ QEMU_PLUGIN_EXPORT int qemu_plugin_install(qemu_plugin_id_t id,
>> }
>> }
>>
>> + if (do_inline && do_callback) {
>> + fprintf(stderr,
>> + "can't enable inline and callback counting at the same time\n");
>> + return -1;
>> + }
>> +
>> + counts = qemu_plugin_scoreboard_new(sizeof(CPUCount));
>> + mem_count = qemu_plugin_scoreboard_u64_in_struct(
>> + counts, CPUCount, mem_count);
>> + io_count = qemu_plugin_scoreboard_u64_in_struct(counts, CPUCount, io_count);
>> qemu_plugin_register_vcpu_tb_trans_cb(id, vcpu_tb_trans);
>> qemu_plugin_register_atexit_cb(id, plugin_exit, NULL);
>> return 0;
>
> You need the following to keep check-tcg working:
>
> modified tests/tcg/Makefile.target
> @@ -168,7 +168,7 @@ RUN_TESTS+=$(EXTRA_RUNS)
>
> # Some plugins need additional arguments above the default to fully
> # exercise things. We can define them on a per-test basis here.
> -run-plugin-%-with-libmem.so: PLUGIN_ARGS=$(COMMA)inline=true$(COMMA)callback=true
> +run-plugin-%-with-libmem.so: PLUGIN_ARGS=$(COMMA)inline=true
>
> ifeq ($(filter %-softmmu, $(TARGET)),)
> run-%: %
>
Missed that, will fix in next version. Thanks!
^ permalink raw reply [flat|nested] 15+ messages in thread
end of thread, other threads:[~2024-03-01 9:45 UTC | newest]
Thread overview: 15+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2024-02-29 5:24 [PATCH v6 00/12] TCG Plugin inline operation enhancement Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 01/12] plugins: scoreboard API Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 02/12] plugins: define qemu_plugin_u64 Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 03/12] plugins: implement inline operation relative to cpu_index Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 04/12] plugins: add inline operation per vcpu Pierrick Bouvier
2024-02-29 5:24 ` [PATCH v6 05/12] tests/plugin: add test plugin for inline operations Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 06/12] tests/plugin/mem: migrate to new per_vcpu API Pierrick Bouvier
2024-02-29 18:08 ` Alex Bennée
2024-03-01 9:40 ` Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 07/12] tests/plugin/insn: " Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 08/12] tests/plugin/bb: " Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 09/12] contrib/plugins/hotblocks: " Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 10/12] contrib/plugins/howvec: " Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 11/12] plugins: remove non per_vcpu inline operation from API Pierrick Bouvier
2024-02-29 5:25 ` [PATCH v6 12/12] plugins: cleanup codepath for previous inline operation Pierrick Bouvier
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).