[Intel-gfx] [PATCH i-g-t 1/2] intel_gpu_top: Support exiting the tool by pressing 'q'

[Intel-gfx] [PATCH i-g-t 1/2] intel_gpu_top: Support exiting the tool by pressing 'q'

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

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 <tvrtko.ursulin@intel.com>
---
 man/intel_gpu_top.rst |  6 ++++
 tools/intel_gpu_top.c | 77 +++++++++++++++++++++++++++++++++++--------
 2 files changed, 70 insertions(+), 13 deletions(-)

diff --git a/man/intel_gpu_top.rst b/man/intel_gpu_top.rst
index 5552e9699d26..2e0c3a05acc1 100644
--- a/man/intel_gpu_top.rst
+++ b/man/intel_gpu_top.rst
@@ -48,6 +48,12 @@ OPTIONS
 -d
     Select a specific GPU using supported filter.
 
+RUNTIME CONTROL
+===============
+
+Supported keys:
+
+    'q'    Exit from the tool.
 
 DEVICE SELECTION
 ================
diff --git a/tools/intel_gpu_top.c b/tools/intel_gpu_top.c
index dbd353673e55..68911940f1d0 100644
--- a/tools/intel_gpu_top.c
+++ b/tools/intel_gpu_top.c
@@ -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;
 }
 
+static void interactive_stdin(void)
+{
+	struct termios termios = { };
+	int ret;
+
+	ret = fcntl(0, F_GETFL, NULL);
+	ret |= O_NONBLOCK;
+	ret = fcntl(0, F_SETFL, ret);
+	assert(ret == 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. */
+
+	ret = tcsetattr(0, TCSAFLUSH, &termios);
+	assert(ret == 0);
+}
+
+static void process_stdin(unsigned int timeout_us)
+{
+	struct pollfd p = { .fd = 0, .events = POLLIN };
+	int ret;
+
+	ret = poll(&p, 1, timeout_us / 1000);
+	if (ret <= 0) {
+		if (ret < 0)
+			stop_top = true;
+		return;
+	}
+
+	for (;;) {
+		char c;
+
+		ret = read(0, &c, 1);
+		if (ret <= 0)
+			break;
+
+		switch (c) {
+		case 'q':
+			stop_top = true;
+			break;
+		};
+	}
+}
+
 int main(int argc, char **argv)
 {
 	unsigned int period_us = DEFAULT_PERIOD_MS * 1000;
@@ -1315,6 +1365,7 @@ int main(int argc, char **argv)
 	switch (output_mode) {
 	case INTERACTIVE:
 		pops = &term_pops;
+		interactive_stdin();
 		break;
 	case STDOUT:
 		pops = &stdout_pops;
@@ -1427,7 +1478,7 @@ int main(int argc, char **argv)
 		if (stop_top)
 			break;
 
-		usleep(period_us);
+		process_stdin(period_us);
 	}
 
 	free(codename);
-- 
2.25.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH i-g-t 2/2] intel_gpu_top: Aggregate engine busyness per class

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

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 <tvrtko.ursulin@intel.com>
---
 man/intel_gpu_top.rst |   1 +
 tools/intel_gpu_top.c | 192 +++++++++++++++++++++++++++++++++++++++---
 2 files changed, 180 insertions(+), 13 deletions(-)

diff --git a/man/intel_gpu_top.rst b/man/intel_gpu_top.rst
index 2e0c3a05acc1..35ab10da9bb4 100644
--- a/man/intel_gpu_top.rst
+++ b/man/intel_gpu_top.rst
@@ -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
 ================
diff --git a/tools/intel_gpu_top.c b/tools/intel_gpu_top.c
index 68911940f1d0..8c4280aa19b9 100644
--- a/tools/intel_gpu_top.c
+++ b/tools/intel_gpu_top.c
@@ -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++;
+	}
+
+	for (i = 0; i < num; i++) {
+		classes[i].class = i;
+		classes[i].name = class_display_name(i);
+	}
+
+	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;
+}
+
+static void __pmu_normalize(struct pmu_pair *val, unsigned int n)
+{
+	val->prev /= n;
+	val->cur /= n;
+}
+
+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);
+			}
+		}
+
+		__pmu_normalize(&engine->busy.val, num_engines);
+		__pmu_normalize(&engine->sema.val, num_engines);
+		__pmu_normalize(&engine->wait.val, num_engines);
+	}
+
+	return classes;
+}
+
+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);
+	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)
-- 
2.25.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [igt-dev] [PATCH i-g-t 1/2] intel_gpu_top: Support exiting the tool by pressing 'q'

[Chris Wilson]

Quoting Tvrtko Ursulin (2020-12-16 15:28:08)
> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> 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 <tvrtko.ursulin@intel.com>
> ---
>  man/intel_gpu_top.rst |  6 ++++
>  tools/intel_gpu_top.c | 77 +++++++++++++++++++++++++++++++++++--------
>  2 files changed, 70 insertions(+), 13 deletions(-)
> 
> diff --git a/man/intel_gpu_top.rst b/man/intel_gpu_top.rst
> index 5552e9699d26..2e0c3a05acc1 100644
> --- a/man/intel_gpu_top.rst
> +++ b/man/intel_gpu_top.rst
> @@ -48,6 +48,12 @@ OPTIONS
>  -d
>      Select a specific GPU using supported filter.
>  
> +RUNTIME CONTROL
> +===============
> +
> +Supported keys:
> +
> +    'q'    Exit from the tool.
>  
>  DEVICE SELECTION
>  ================
> diff --git a/tools/intel_gpu_top.c b/tools/intel_gpu_top.c
> index dbd353673e55..68911940f1d0 100644
> --- a/tools/intel_gpu_top.c
> +++ b/tools/intel_gpu_top.c
> @@ -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;
>  }
>  
> +static void interactive_stdin(void)
> +{
> +       struct termios termios = { };
> +       int ret;
> +
> +       ret = fcntl(0, F_GETFL, NULL);
> +       ret |= O_NONBLOCK;
> +       ret = fcntl(0, F_SETFL, ret);
> +       assert(ret == 0);

I always have to double check that O_NONBLOCK is in F_SETFL and not
F_SETFD.

> +
> +       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. */
> +
> +       ret = tcsetattr(0, TCSAFLUSH, &termios);
> +       assert(ret == 0);
> +}
> +
> +static void process_stdin(unsigned int timeout_us)
> +{
> +       struct pollfd p = { .fd = 0, .events = POLLIN };
> +       int ret;
> +
> +       ret = poll(&p, 1, timeout_us / 1000);

Replacing the usleep in the mainloop.

Hmm. Won't this have a problem if this run as a daemon (with stdin
closed)?

> +       if (ret <= 0) {
> +               if (ret < 0)
> +                       stop_top = true;
> +               return;
> +       }
> +
> +       for (;;) {
> +               char c;
> +
> +               ret = read(0, &c, 1);
> +               if (ret <= 0)
> +                       break;

O_NONBLOCK on 0.

So on each mainloop, we check for a key press, consume all that are in
the buffer, then return to the mainloop.

> +
> +               switch (c) {
> +               case 'q':
> +                       stop_top = true;
> +                       break;
> +               };
> +       }
> +}
> +
>  int main(int argc, char **argv)
>  {
>         unsigned int period_us = DEFAULT_PERIOD_MS * 1000;
> @@ -1315,6 +1365,7 @@ int main(int argc, char **argv)
>         switch (output_mode) {
>         case INTERACTIVE:

INTERACTIVE is the default mode when run in a terminal.

>                 pops = &term_pops;
> +               interactive_stdin();
>                 break;
>         case STDOUT:
>                 pops = &stdout_pops;
> @@ -1427,7 +1478,7 @@ int main(int argc, char **argv)
>                 if (stop_top)
>                         break;
>  
> -               usleep(period_us);
> +               process_stdin(period_us);

Just the question about what happens if run with 0 closed...

if (!process_stdin(period_us))
	usleep(period_us);
?

>         }
>  
>         free(codename);
> -- 
> 2.25.1
> 
> _______________________________________________
> igt-dev mailing list
> igt-dev@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/igt-dev
>
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [igt-dev] [PATCH i-g-t 2/2] intel_gpu_top: Aggregate engine busyness per class

[Chris Wilson]

Quoting Tvrtko Ursulin (2020-12-16 15:28:09)
> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> 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 <tvrtko.ursulin@intel.com>
> ---
>  man/intel_gpu_top.rst |   1 +
>  tools/intel_gpu_top.c | 192 +++++++++++++++++++++++++++++++++++++++---
>  2 files changed, 180 insertions(+), 13 deletions(-)
> 
> diff --git a/man/intel_gpu_top.rst b/man/intel_gpu_top.rst
> index 2e0c3a05acc1..35ab10da9bb4 100644
> --- a/man/intel_gpu_top.rst
> +++ b/man/intel_gpu_top.rst
> @@ -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
>  ================
> diff --git a/tools/intel_gpu_top.c b/tools/intel_gpu_top.c
> index 68911940f1d0..8c4280aa19b9 100644
> --- a/tools/intel_gpu_top.c
> +++ b/tools/intel_gpu_top.c
> @@ -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++;
> +       }
> +
> +       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?

> +
> +       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;
> +}
> +
> +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.

> +}
> +
> +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);
> +                       }
> +               }
> +
> +               __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.

> +       }
> +
> +       return classes;
> +}
> +
> +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.

> +       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)
> -- 
> 2.25.1
> 
> _______________________________________________
> igt-dev mailing list
> igt-dev@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/igt-dev
>
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [igt-dev] [PATCH i-g-t 2/2] intel_gpu_top: Aggregate engine busyness per class

[Chris Wilson]

Quoting Chris Wilson (2020-12-16 15:51:59)
> Quoting Tvrtko Ursulin (2020-12-16 15:28:09)
> > From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> > 
> > 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 <tvrtko.ursulin@intel.com>

Where were my manners?
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH v2 i-g-t 1/2] intel_gpu_top: Support exiting the tool by pressing 'q'

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

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 <tvrtko.ursulin@intel.com>
---
 man/intel_gpu_top.rst |  6 ++++
 tools/intel_gpu_top.c | 80 ++++++++++++++++++++++++++++++++++++-------
 2 files changed, 73 insertions(+), 13 deletions(-)

diff --git a/man/intel_gpu_top.rst b/man/intel_gpu_top.rst
index 5552e9699d26..2e0c3a05acc1 100644
--- a/man/intel_gpu_top.rst
+++ b/man/intel_gpu_top.rst
@@ -48,6 +48,12 @@ OPTIONS
 -d
     Select a specific GPU using supported filter.
 
+RUNTIME CONTROL
+===============
+
+Supported keys:
+
+    'q'    Exit from the tool.
 
 DEVICE SELECTION
 ================
diff --git a/tools/intel_gpu_top.c b/tools/intel_gpu_top.c
index dbd353673e55..46221c9543eb 100644
--- a/tools/intel_gpu_top.c
+++ b/tools/intel_gpu_top.c
@@ -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;
 }
 
+static void interactive_stdin(void)
+{
+	struct termios termios = { };
+	int ret;
+
+	ret = fcntl(0, F_GETFL, NULL);
+	ret |= O_NONBLOCK;
+	ret = fcntl(0, F_SETFL, ret);
+	assert(ret == 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. */
+
+	ret = tcsetattr(0, TCSAFLUSH, &termios);
+	assert(ret == 0);
+}
+
+static void process_stdin(unsigned int timeout_us)
+{
+	struct pollfd p = { .fd = 0, .events = POLLIN };
+	int ret;
+
+	ret = poll(&p, 1, timeout_us / 1000);
+	if (ret <= 0) {
+		if (ret < 0)
+			stop_top = true;
+		return;
+	}
+
+	for (;;) {
+		char c;
+
+		ret = read(0, &c, 1);
+		if (ret <= 0)
+			break;
+
+		switch (c) {
+		case 'q':
+			stop_top = true;
+			break;
+		};
+	}
+}
+
 int main(int argc, char **argv)
 {
 	unsigned int period_us = DEFAULT_PERIOD_MS * 1000;
@@ -1315,6 +1365,7 @@ int main(int argc, char **argv)
 	switch (output_mode) {
 	case INTERACTIVE:
 		pops = &term_pops;
+		interactive_stdin();
 		break;
 	case STDOUT:
 		pops = &stdout_pops;
@@ -1427,7 +1478,10 @@ int main(int argc, char **argv)
 		if (stop_top)
 			break;
 
-		usleep(period_us);
+		if (output_mode == INTERACTIVE)
+			process_stdin(period_us);
+		else
+			usleep(period_us);
 	}
 
 	free(codename);
-- 
2.25.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH v2 i-g-t 1/2] intel_gpu_top: Support exiting the tool by pressing 'q'

[Chris Wilson]

Quoting Tvrtko Ursulin (2020-12-16 15:54:20)
> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> 
> 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 <tvrtko.ursulin@intel.com>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [igt-dev] [PATCH i-g-t 2/2] intel_gpu_top: Aggregate engine busyness per class

[Tvrtko Ursulin]

On 16/12/2020 15:51, Chris Wilson wrote:
> Quoting Tvrtko Ursulin (2020-12-16 15:28:09)
>> From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
>>
>> 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 <tvrtko.ursulin@intel.com>
>> ---
>>   man/intel_gpu_top.rst |   1 +
>>   tools/intel_gpu_top.c | 192 +++++++++++++++++++++++++++++++++++++++---
>>   2 files changed, 180 insertions(+), 13 deletions(-)
>>
>> diff --git a/man/intel_gpu_top.rst b/man/intel_gpu_top.rst
>> index 2e0c3a05acc1..35ab10da9bb4 100644
>> --- a/man/intel_gpu_top.rst
>> +++ b/man/intel_gpu_top.rst
>> @@ -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
>>   ================
>> diff --git a/tools/intel_gpu_top.c b/tools/intel_gpu_top.c
>> index 68911940f1d0..8c4280aa19b9 100644
>> --- a/tools/intel_gpu_top.c
>> +++ b/tools/intel_gpu_top.c
>> @@ -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++;
>> +       }
>> +
>> +       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?

I need this array 1:1 with class ids so no. I didn't find yet that 
"empty" entries would cause a problem anywhere in the code. Hm actually 
there wouldn't be any empty classes, since class generation is driven of 
discovered engines.

I need to sprinkle some more asserts and comments around.

> 
>> +
>> +       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;
>> +}
>> +
>> +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.

Yeah, this allows basically no changes to existing code.

Maybe a running average algorithm would be better to not overflow the 
u64 but I haven't bothered calculating if that is a theoretical 
possibility or not.

> 
>> +}
>> +
>> +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);
>> +                       }
>> +               }
>> +
>> +               __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.

Yes, and then just pass this wrapped/aggregated struct engines * to the 
existing code.

>> +       }
>> +
>> +       return classes;
>> +}
>> +
>> +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.

Regards,

Tvrtko
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [igt-dev] [PATCH i-g-t 2/2] intel_gpu_top: Aggregate engine busyness per class

[Chris Wilson]

Quoting Tvrtko Ursulin (2020-12-16 16:01:30)
> 
> On 16/12/2020 15:51, Chris Wilson wrote:
> > Quoting Tvrtko Ursulin (2020-12-16 15:28:09)
> >> +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.

show = update_classes(engines);

with update_classes doing the if (once) classes = init_classes(engines) ?
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH v2 i-g-t 2/2] intel_gpu_top: Aggregate engine busyness per class

[Tvrtko Ursulin]

From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>

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.

v2:
 * Fix building the aggregated engines.
 * Tidy static variable handling.

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
---
 man/intel_gpu_top.rst |   1 +
 tools/intel_gpu_top.c | 208 +++++++++++++++++++++++++++++++++++++++---
 2 files changed, 196 insertions(+), 13 deletions(-)

diff --git a/man/intel_gpu_top.rst b/man/intel_gpu_top.rst
index 2e0c3a05acc1..35ab10da9bb4 100644
--- a/man/intel_gpu_top.rst
+++ b/man/intel_gpu_top.rst
@@ -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
 ================
diff --git a/tools/intel_gpu_top.c b/tools/intel_gpu_top.c
index 46221c9543eb..9ae30b8020dc 100644
--- a/tools/intel_gpu_top.c
+++ b/tools/intel_gpu_top.c
@@ -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,180 @@ 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++;
+	}
+
+	for (i = 0; i < num; i++) {
+		classes[i].class = i;
+		classes[i].name = class_display_name(i);
+	}
+
+	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;
+}
+
+static void __pmu_normalize(struct pmu_pair *val, unsigned int n)
+{
+	val->prev /= n;
+	val->cur /= n;
+}
+
+static struct engines *init_class_engines(struct engines *engines)
+{
+	unsigned int num_present;
+	struct engines *classes;
+	unsigned int i, j, k;
+
+	init_engine_classes(engines);
+
+	num_present = 0; /* Classes with engines. */
+	for (i = 0; i < engines->num_classes; i++) {
+		if (engines->class[i].num_engines)
+			num_present++;
+	}
+
+	classes = calloc(1, sizeof(struct engines) +
+			    num_present * sizeof(struct engine));
+	assert(classes);
+
+	classes->num_engines = num_present;
+	classes->num_classes = engines->num_classes;
+	classes->class = engines->class;
+
+	j = 0;
+	for (i = 0; i < engines->num_classes; i++) {
+		struct engine *engine = engine_ptr(classes, j);
+
+		/* Skip classes with no engines. */
+		if (!engines->class[i].num_engines)
+			continue;
+
+		assert(j < num_present);
+
+		engine->class = i;
+		engine->instance = -1;
+
+		engine->display_name = strdup(class_display_name(i));
+		assert(engine->display_name);
+		engine->short_name = strdup(class_short_name(i));
+		assert(engine->short_name);
+
+		/*
+		 * Copy over pmu metadata from one real engine of the same
+		 * class.
+		 */
+		for (k = 0; k < engines->num_engines; k++) {
+			struct engine *e = engine_ptr(engines, k);
+
+			if (e->class == i) {
+				engine->num_counters = e->num_counters;
+				engine->busy = e->busy;
+				engine->sema = e->sema;
+				engine->wait = e->wait;
+				break;
+			}
+		}
+
+		j++; /* Next "class engine" to populate. */
+	}
+
+	return classes;
+}
+
+static struct engines *update_class_engines(struct engines *engines)
+{
+	static struct engines *classes;
+	unsigned int i, j;
+
+	if (!classes)
+		classes = init_class_engines(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);
+
+		assert(num_engines);
+
+		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);
+			}
+		}
+
+		__pmu_normalize(&engine->busy.val, num_engines);
+		__pmu_normalize(&engine->sema.val, num_engines);
+		__pmu_normalize(&engine->wait.val, num_engines);
+	}
+
+	return classes;
+}
+
+static int
+print_engines(struct engines *engines, double t, int lines, int w, int h)
+{
+	struct engines *show;
+
+	if (class_view)
+		show = update_class_engines(engines);
+	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 +1481,9 @@ static void process_stdin(unsigned int timeout_us)
 		case 'q':
 			stop_top = true;
 			break;
+		case '1':
+			class_view ^= true;
+			break;
 		};
 	}
 }
@@ -1302,7 +1494,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 +1557,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 +1654,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)
-- 
2.25.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH v2 i-g-t 1/2] intel_gpu_top: Support exiting the tool by pressing 'q'

[Chris Wilson]

Quoting Chris Wilson (2020-12-16 15:57:53)
> Quoting Tvrtko Ursulin (2020-12-16 15:54:20)
> > From: Tvrtko Ursulin <tvrtko.ursulin@intel.com>
> > 
> > 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 <tvrtko.ursulin@intel.com>
> Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>

I've only used this once, and I already miss it.
-Chris
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx