diff mbox series

[v5,07/12] tests/plugin/insn: migrate to new per_vcpu API

Message ID 20240226091446.479436-8-pierrick.bouvier@linaro.org (mailing list archive)
State New, archived
Headers show
Series TCG Plugin inline operation enhancement | expand

Commit Message

Pierrick Bouvier Feb. 26, 2024, 9:14 a.m. UTC 
Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>
---
 tests/plugin/insn.c | 106 +++++++++++++++++++++-----------------------
 1 file changed, 50 insertions(+), 56 deletions(-)

Comments

Luc Michel Feb. 27, 2024, 9:50 a.m. UTC | #1 
On 13:14 Mon 26 Feb     , Pierrick Bouvier wrote:
> Signed-off-by: Pierrick Bouvier <pierrick.bouvier@linaro.org>

Reviewed-by: Luc Michel <luc.michel@amd.com>

> ---
>  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
> 
> 

--
diff mbox series

Patch

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);