intel_gpu_top: Support exiting the tool by pressing 'q'

From: Tvrtko Ursulin <[email protected]>

Similarly to how top(1) handles SMP, we can default to showing engines of a same class as a single bar graph entry.

To achieve this a little bit of hackery is employed. PMU sampling is left as is and only at the presentation layer we create a fake set of engines, one for each class, summing and normalizing the load respectively.

Signed-off-by Tvrtko Ursulin <[email protected]>

---
 man/intel_gpu_top.rst |   1 +
 tools/intel_gpu_top.c | 192 +++++++++++++++++++++++++++++++++++++++---
 2 files changed, 180 insertions(+), 13 deletions(-)

man/intel_gpu_top.rst +1 -0

index 2e0c3a05acc1..35ab10da9bb4 100644
@@ -54,6 +54,7 @@ RUNTIME CONTROL
 Supported keys:
 
     'q'    Exit from the tool.
+    '1'    Toggle between aggregated engine class and physical engine mode.
 
 DEVICE SELECTION
 ================

tools/intel_gpu_top.c +43 -1

index 68911940f1d0..8c4280aa19b9 100644
@@ -76,8 +76,16 @@ struct engine {
        struct pmu_counter sema;
 };
 
+struct engine_class {
+       unsigned int class;
+       const char *name;
+       unsigned int num_engines;
+};
+
 struct engines {
        unsigned int num_engines;
+       unsigned int num_classes;
+       struct engine_class *class;
        unsigned int num_counters;
        DIR *root;
        int fd;

@@ -1118,6 +1126,8 @@ print_imc(struct engines *engines, double t, int lines, int con_w, int con_h)
        return lines;
 }
 
+static bool class_view;
+
 static int
 print_engines_header(struct engines *engines, double t,
                     int lines, int con_w, int con_h)

@@ -1133,8 +1143,13 @@ print_engines_header(struct engines *engines, double t,
                pops->open_struct("engines");
 
                if (output_mode == INTERACTIVE) {
-                       const char *a = "          ENGINE      BUSY ";
                        const char *b = " MI_SEMA MI_WAIT";
+                       const char *a;
+
+                       if (class_view)
+                               a = "         ENGINES     BUSY  ";
+                       else
+                               a = "          ENGINE     BUSY  ";
 
                        printf("\033[7m%s%*s%s\033[0m\n",
                               a, (int)(con_w - 1 - strlen(a) - strlen(b)),

@@ -1214,6 +1229,164 @@ print_engines_footer(struct engines *engines, double t,
        return lines;
 }
 
+static int class_cmp(const void *_a, const void *_b)
+{
+       const struct engine_class *a = _a;
+       const struct engine_class *b = _b;
+
+       return a->class - b->class;
+}
+
+static void init_engine_classes(struct engines *engines)
+{
+       struct engine_class *classes;
+       unsigned int i, num;
+       int max = -1;
+
+       for (i = 0; i < engines->num_engines; i++) {
+               struct engine *engine = engine_ptr(engines, i);
+
+               if ((int)engine->class > max)
+                       max = engine->class;
+       }
+       assert(max >= 0);
+
+       num = max + 1;
+
+       classes = calloc(num, sizeof(*classes));
+       assert(classes);
+

tools/intel_gpu_top.c +7 -0

+
+       qsort(classes, num, sizeof(*classes), class_cmp);
+
+       engines->num_classes = num;
+       engines->class = classes;
+}
+

tools/intel_gpu_top.c +68 -0

+}
+
+static struct engines *init_classes(struct engines *engines)
+{
+       struct engines *classes;
+       unsigned int i, j;
+
+       init_engine_classes(engines);
+
+       classes = calloc(1, sizeof(struct engines) +
+                           engines->num_classes * sizeof(struct engine));
+       assert(classes);
+
+       classes->num_engines = engines->num_classes;
+       classes->num_classes = engines->num_classes;
+       classes->class = engines->class;
+
+       for (i = 0; i < engines->num_classes; i++) {
+               struct engine *engine = engine_ptr(classes, i);
+
+               engine->class = i;
+               engine->instance = -1;
+
+               if (!engines->class[i].num_engines)
+                       continue;
+
+               engine->display_name = strdup(class_display_name(i));
+               assert(engine->display_name);
+               engine->short_name = strdup(class_short_name(i));
+               assert(engine->short_name);
+
+               for (j = 0; j < engines->num_engines; j++) {
+                       struct engine *e = engine_ptr(engines, j);
+
+                       if (e->class == i) {
+                               engine->num_counters = e->num_counters;
+                               engine->busy = e->busy;
+                               engine->sema = e->sema;
+                               engine->wait = e->wait;
+                       }
+               }
+       }
+
+       return classes;
+}
+
+static struct engines *
+update_classes(struct engines *classes, struct engines *engines)
+{
+       unsigned int i, j;
+
+       if (!classes)
+               classes = init_classes(engines);
+
+       for (i = 0; i < classes->num_engines; i++) {
+               unsigned int num_engines = classes->class[i].num_engines;
+               struct engine *engine = engine_ptr(classes, i);
+
+               if (!num_engines)
+                       continue;
+
+               memset(&engine->busy.val, 0, sizeof(engine->busy.val));
+               memset(&engine->sema.val, 0, sizeof(engine->sema.val));
+               memset(&engine->wait.val, 0, sizeof(engine->wait.val));
+
+               for (j = 0; j < engines->num_engines; j++) {
+                       struct engine *e = engine_ptr(engines, j);
+

tools/intel_gpu_top.c +18 -12

+       else
+               show = engines;
+
+       lines = print_engines_header(show, t, lines, w,  h);
+
+       for (unsigned int i = 0; i < show->num_engines && lines < h; i++)
+               lines = print_engine(show, i, t, lines, w, h);
+
+       lines = print_engines_footer(show, t, lines, w, h);
+
+       return lines;
+}
+
 static bool stop_top;
 
 static void sigint_handler(int  sig)

@@ -1292,6 +1465,9 @@ static void process_stdin(unsigned int timeout_us)
                case 'q':
                        stop_top = true;
                        break;
+               case '1':
+                       class_view ^= true;
+                       break;
                };
        }
 }

@@ -1302,7 +1478,6 @@ int main(int argc, char **argv)
        int con_w = -1, con_h = -1;
        char *output_path = NULL;
        struct engines *engines;
-       unsigned int i;
        int ret = 0, ch;
        bool list_device = false;
        char *pmu_device, *opt_device = NULL;

@@ -1366,6 +1541,7 @@ int main(int argc, char **argv)
        case INTERACTIVE:
                pops = &term_pops;
                interactive_stdin();
+               class_view = true;
                break;
        case STDOUT:
                pops = &stdout_pops;

@@ -1462,17 +1638,7 @@ int main(int argc, char **argv)
 
                        lines = print_imc(engines, t, lines, con_w, con_h);
 
-                       lines = print_engines_header(engines, t, lines, con_w,
-                                                    con_h);
-
-                       for (i = 0;
-                            i < engines->num_engines && lines < con_h;
-                            i++)
-                               lines = print_engine(engines, i, t, lines,
-                                                    con_w, con_h);
-
-                       lines = print_engines_footer(engines, t, lines, con_w,
-                                                    con_h);
+                       lines = print_engines(engines, t, lines, con_w, con_h);
                }
 
                if (stop_top)

Signature · 6 lines

2.25.1

_______________________________________________
igt-dev mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/igt-dev

Quoting Tvrtko Ursulin (2020-12-16 15:28:09)

Quoted 10 lines

From: Tvrtko Ursulin <[email protected]>

Similarly to how top(1) handles SMP, we can default to showing engines of a same class as a single bar graph entry.

To achieve this a little bit of hackery is employed. PMU sampling is left as is and only at the presentation layer we create a fake set of engines, one for each class, summing and normalizing the load respectively.

Signed-off-by Tvrtko Ursulin <[email protected]>

Quoting Tvrtko Ursulin (2020-12-16 15:28:09)

Quoted 107 lines

From: Tvrtko Ursulin <[email protected]>

Similarly to how top(1) handles SMP, we can default to showing engines of a same class as a single bar graph entry.

To achieve this a little bit of hackery is employed. PMU sampling is left as is and only at the presentation layer we create a fake set of engines, one for each class, summing and normalizing the load respectively.

Signed-off-by Tvrtko Ursulin <[email protected]>

---
  man/intel_gpu_top.rst |   1 +
  tools/intel_gpu_top.c | 192 +++++++++++++++++++++++++++++++++++++++---
  2 files changed, 180 insertions(+), 13 deletions(-)

man/intel_gpu_top.rst +1 -0

index 2e0c3a05acc1..35ab10da9bb4 100644
@@ -54,6 +54,7 @@ RUNTIME CONTROL
  Supported keys:
 
      'q'    Exit from the tool.
+    '1'    Toggle between aggregated engine class and physical engine mode.
 
  DEVICE SELECTION
  ================

tools/intel_gpu_top.c +47 -1

index 68911940f1d0..8c4280aa19b9 100644
@@ -76,8 +76,16 @@ struct engine {
         struct pmu_counter sema;
  };
 
+struct engine_class {
+       unsigned int class;
+       const char *name;
+       unsigned int num_engines;
+};
+
  struct engines {
         unsigned int num_engines;
+       unsigned int num_classes;
+       struct engine_class *class;
         unsigned int num_counters;
         DIR *root;
         int fd;

@@ -1118,6 +1126,8 @@ print_imc(struct engines *engines, double t, int lines, int con_w, int con_h)
         return lines;
  }
 
+static bool class_view;
+
  static int
  print_engines_header(struct engines *engines, double t,
                      int lines, int con_w, int con_h)

@@ -1133,8 +1143,13 @@ print_engines_header(struct engines *engines, double t,
                 pops->open_struct("engines");
 
                 if (output_mode == INTERACTIVE) {
-                       const char *a = "          ENGINE      BUSY ";
                         const char *b = " MI_SEMA MI_WAIT";
+                       const char *a;
+
+                       if (class_view)
+                               a = "         ENGINES     BUSY  ";
+                       else
+                               a = "          ENGINE     BUSY  ";
 
                         printf("\033[7m%s%*s%s\033[0m\n",
                                a, (int)(con_w - 1 - strlen(a) - strlen(b)),

@@ -1214,6 +1229,164 @@ print_engines_footer(struct engines *engines, double t,
         return lines;
  }
 
+static int class_cmp(const void *_a, const void *_b)
+{
+       const struct engine_class *a = _a;
+       const struct engine_class *b = _b;
+
+       return a->class - b->class;
+}
+
+static void init_engine_classes(struct engines *engines)
+{
+       struct engine_class *classes;
+       unsigned int i, num;
+       int max = -1;
+
+       for (i = 0; i < engines->num_engines; i++) {
+               struct engine *engine = engine_ptr(engines, i);
+
+               if ((int)engine->class > max)
+                       max = engine->class;
+       }
+       assert(max >= 0);
+
+       num = max + 1;
+
+       classes = calloc(num, sizeof(*classes));
+       assert(classes);
+
+       for (i = 0; i < engines->num_engines; i++) {
+               struct engine *engine = engine_ptr(engines, i);
+
+               classes[engine->class].num_engines++;

tools/intel_gpu_top.c print_engines_footer(struct engines *engines, double t, · line 1268

Quoted 6 lines

tools/intel_gpu_top.c +6 -0

+       }
+
+       for (i = 0; i < num; i++) {
+               classes[i].class = i;
+               classes[i].name = class_display_name(i);
+       }

Do you want to remove empty classes at this point?

Quoted 12 lines

tools/intel_gpu_top.c +11 -0

+
+       qsort(classes, num, sizeof(*classes), class_cmp);
+
+       engines->num_classes = num;
+       engines->class = classes;
+}
+
+static void __pmu_sum(struct pmu_pair *dst, struct pmu_pair *src)
+{
+       dst->prev += src->prev;
+       dst->cur += src->cur;

tools/intel_gpu_top.c print_engines_footer(struct engines *engines, double t, · line 1285

Quoted 6 lines

tools/intel_gpu_top.c +6 -0

+}
+
+static void __pmu_normalize(struct pmu_pair *val, unsigned int n)
+{
+       val->prev /= n;
+       val->cur /= n;

I was expecting just the delta to be normalized. This works as well.

Quoted 74 lines

tools/intel_gpu_top.c +73 -0

+}
+
+static struct engines *init_classes(struct engines *engines)
+{
+       struct engines *classes;
+       unsigned int i, j;
+
+       init_engine_classes(engines);
+
+       classes = calloc(1, sizeof(struct engines) +
+                           engines->num_classes * sizeof(struct engine));
+       assert(classes);
+
+       classes->num_engines = engines->num_classes;
+       classes->num_classes = engines->num_classes;
+       classes->class = engines->class;
+
+       for (i = 0; i < engines->num_classes; i++) {
+               struct engine *engine = engine_ptr(classes, i);
+
+               engine->class = i;
+               engine->instance = -1;
+
+               if (!engines->class[i].num_engines)
+                       continue;
+
+               engine->display_name = strdup(class_display_name(i));
+               assert(engine->display_name);
+               engine->short_name = strdup(class_short_name(i));
+               assert(engine->short_name);
+
+               for (j = 0; j < engines->num_engines; j++) {
+                       struct engine *e = engine_ptr(engines, j);
+
+                       if (e->class == i) {
+                               engine->num_counters = e->num_counters;
+                               engine->busy = e->busy;
+                               engine->sema = e->sema;
+                               engine->wait = e->wait;
+                       }
+               }
+       }
+
+       return classes;
+}
+
+static struct engines *
+update_classes(struct engines *classes, struct engines *engines)
+{
+       unsigned int i, j;
+
+       if (!classes)
+               classes = init_classes(engines);
+
+       for (i = 0; i < classes->num_engines; i++) {
+               unsigned int num_engines = classes->class[i].num_engines;
+               struct engine *engine = engine_ptr(classes, i);
+
+               if (!num_engines)
+                       continue;
+
+               memset(&engine->busy.val, 0, sizeof(engine->busy.val));
+               memset(&engine->sema.val, 0, sizeof(engine->sema.val));
+               memset(&engine->wait.val, 0, sizeof(engine->wait.val));
+
+               for (j = 0; j < engines->num_engines; j++) {
+                       struct engine *e = engine_ptr(engines, j);
+
+                       if (e->class == i) {
+                               __pmu_sum(&engine->busy.val, &e->busy.val);
+                               __pmu_sum(&engine->sema.val, &e->sema.val);
+                               __pmu_sum(&engine->wait.val, &e->wait.val);
+                       }

tools/intel_gpu_top.c print_engines_footer(struct engines *engines, double t, · line 1363

Quoted 5 lines

tools/intel_gpu_top.c +5 -0

+               }
+
+               __pmu_normalize(&engine->busy.val, num_engines);
+               __pmu_normalize(&engine->sema.val, num_engines);
+               __pmu_normalize(&engine->wait.val, num_engines);

Ok. So you wrap the normal engines with class_view, where each engine in that class_view is an average of all engines within it.

Quoted 7 lines

tools/intel_gpu_top.c +7 -0

+       }
+
+       return classes;
+}
+
+static int
+print_engines(struct engines *engines, double t, int lines, int w, int h)

tools/intel_gpu_top.c print_engines_footer(struct engines *engines, double t, · line 1376

Quoted 6 lines

tools/intel_gpu_top.c +6 -0

+{
+       static struct engines *classes;
+       struct engines *show;
+
+       if (class_view)
+               classes = show = update_classes(classes, engines);

Something is not right here. Oh static, nvm.

Quoted 11 lines

Quoting Tvrtko Ursulin (2020-12-16 15:28:09)

tools/intel_gpu_top.c print_engines_footer(struct engines *engines, double t, · line 1376

Quoted 8 lines

tools/intel_gpu_top.c +8 -0

+static int
+print_engines(struct engines *engines, double t, int lines, int w, int h)
+{
+       static struct engines *classes;
+       struct engines *show;
+
+       if (class_view)
+               classes = show = update_classes(classes, engines);

Something is not right here. Oh static, nvm.

Too hacky? Maybe "show = classes = update_classes()"would read better.

From: Tvrtko Ursulin <[email protected]>

Analoguous to top(1) we can enable the user to exit from the tool by pressing 'q' on the console.

Signed-off-by Tvrtko Ursulin <[email protected]>

---
 man/intel_gpu_top.rst |  6 ++++
 tools/intel_gpu_top.c | 77 +++++++++++++++++++++++++++++++++++--------
 2 files changed, 70 insertions(+), 13 deletions(-)

man/intel_gpu_top.rst +6 -0

index 5552e9699d26..2e0c3a05acc1 100644
@@ -48,6 +48,12 @@ OPTIONS
 -d
     Select a specific GPU using supported filter.
 
+RUNTIME CONTROL
+===============
+
+Supported keys:
+
+    'q'    Exit from the tool.
 
 DEVICE SELECTION
 ================

tools/intel_gpu_top.c +14 -12

index dbd353673e55..68911940f1d0 100644
@@ -23,24 +23,26 @@
 
 #include "igt_device_scan.h"
 
-#include <stdio.h>
-#include <sys/types.h>
-#include <dirent.h>
-#include <stdint.h>
 #include <assert.h>
-#include <string.h>
 #include <ctype.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/stat.h>
+#include <dirent.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
-#include <sys/ioctl.h>
-#include <errno.h>
-#include <math.h>
-#include <locale.h>
 #include <limits.h>
+#include <locale.h>
+#include <math.h>
+#include <poll.h>
 #include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <termios.h>
 
 #include "igt_perf.h"
 

@@ -1246,6 +1248,54 @@ static char *tr_pmu_name(struct igt_device_card *card)
        return device;
 }

tools/intel_gpu_top.c +8 -0

+
+       ret = tcgetattr(0, &termios);
+       assert(ret == 0);
+
+       termios.c_lflag &= ~ICANON;
+       termios.c_cc[VMIN] = 1;
+       termios.c_cc[VTIME] = 0; /* Deciseconds only - we'll use poll. */
+

tools/intel_gpu_top.c +9 -0

+
+               switch (c) {
+               case 'q':
+                       stop_top = true;
+                       break;
+               };
+       }
+}
+
 int main(int argc, char **argv)
 {
        unsigned int period_us = DEFAULT_PERIOD_MS * 1000;

tools/intel_gpu_top.c +0 -0

        }
 
        free(codename);

Signature · 6 lines

2.25.1

_______________________________________________
igt-dev mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/igt-dev

From: Tvrtko Ursulin <[email protected]>

Analoguous to top(1) we can enable the user to exit from the tool by pressing 'q' on the console.

v2:
* Fix sleep period with closed stdin. (Chris)

Signed-off-by Tvrtko Ursulin <[email protected]>

Quoting Tvrtko Ursulin (2020-12-16 15:54:20)

Quoted 9 lines

From: Tvrtko Ursulin <[email protected]>

Analoguous to top(1) we can enable the user to exit from the tool by pressing 'q' on the console.

v2:
* Fix sleep period with closed stdin. (Chris)

Signed-off-by Tvrtko Ursulin <[email protected]>

Reviewed-by Chris Wilson <[email protected]>