[IGT] tools/intel_gpu_top: Add support for stdout logging

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



From: Tvrtko Ursulin <tvrtko.ursulin@xxxxxxxxx>

Two new output modes are added: listing of text data to standard out (-l
on the command line), and dumping of JSON formatted records (-J), also to
standard out.

The first mode is selected automatically when non-interactive standard out
is detected.

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@xxxxxxxxx>
References: https://bugs.freedesktop.org/show_bug.cgi?id=108689
Cc: Eero Tamminen <eero.t.tamminen@xxxxxxxxx>
Cc: 3.14pi@xxxxxxx
---
 man/intel_gpu_top.rst |   9 +-
 tools/intel_gpu_top.c | 742 +++++++++++++++++++++++++++++++++++-------
 2 files changed, 630 insertions(+), 121 deletions(-)

diff --git a/man/intel_gpu_top.rst b/man/intel_gpu_top.rst
index 19c712307d28..d5bda093c8e8 100644
--- a/man/intel_gpu_top.rst
+++ b/man/intel_gpu_top.rst
@@ -7,9 +7,9 @@ Display a top-like summary of Intel GPU usage
 ---------------------------------------------
 .. include:: defs.rst
 :Author: IGT Developers <igt-dev@xxxxxxxxxxxxxxxxxxxxx>
-:Date: 2018-04-04
+:Date: 2019-02-08
 :Version: |PACKAGE_STRING|
-:Copyright: 2009,2011,2012,2016,2018 Intel Corporation
+:Copyright: 2009,2011,2012,2016,2018,2019 Intel Corporation
 :Manual section: |MANUAL_SECTION|
 :Manual group: |MANUAL_GROUP|
 
@@ -31,6 +31,11 @@ OPTIONS
 -s <ms>
     Refresh period in milliseconds.
 
+-l
+    List text data to standard out.
+
+-J
+    Output JSON formatted data to standard output.
 -h
     Show help text.
 
diff --git a/tools/intel_gpu_top.c b/tools/intel_gpu_top.c
index b923c3cfbe97..1313e0d46b5e 100644
--- a/tools/intel_gpu_top.c
+++ b/tools/intel_gpu_top.c
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2007-2018 Intel Corporation
+ * Copyright © 2007-2019 Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -19,10 +19,6 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
- *
- * Authors:
- *    Eric Anholt <eric@xxxxxxxxxx>
- *    Eugeni Dodonov <eugeni.dodonov@xxxxxxxxx>
  */
 
 #include <stdio.h>
@@ -41,6 +37,7 @@
 #include <errno.h>
 #include <math.h>
 #include <locale.h>
+#include <limits.h>
 
 #include "igt_perf.h"
 
@@ -59,6 +56,7 @@ struct pmu_counter {
 struct engine {
 	const char *name;
 	const char *display_name;
+	const char *short_name;
 
 	unsigned int class;
 	unsigned int instance;
@@ -142,6 +140,22 @@ static const char *class_display_name(unsigned int class)
 	}
 }
 
+static const char *class_short_name(unsigned int class)
+{
+	switch (class) {
+	case I915_ENGINE_CLASS_RENDER:
+		return "RCS";
+	case I915_ENGINE_CLASS_COPY:
+		return "BCS";
+	case I915_ENGINE_CLASS_VIDEO:
+		return "VCS";
+	case I915_ENGINE_CLASS_VIDEO_ENHANCE:
+		return "VECS";
+	default:
+		return "UNKN";
+	}
+}
+
 static int engine_cmp(const void *__a, const void *__b)
 {
 	const struct engine *a = (struct engine *)__a;
@@ -227,7 +241,6 @@ static struct engines *discover_engines(void)
 			ret = ENOBUFS;
 			break;
 		}
-		ret = 0;
 
 		engine->display_name = strdup(buf);
 		if (!engine->display_name) {
@@ -235,6 +248,20 @@ static struct engines *discover_engines(void)
 			break;
 		}
 
+		ret = snprintf(buf, sizeof(buf), "%s/%u",
+			       class_short_name(engine->class),
+			       engine->instance);
+		if (ret < 0 || ret == sizeof(buf)) {
+			ret = ENOBUFS;
+			break;
+		}
+
+		engine->short_name = strdup(buf);
+		if (!engine->short_name) {
+			ret = errno;
+			break;
+		}
+
 		engines->num_engines++;
 		engines = realloc(engines, sizeof(struct engines) +
 				  engines->num_engines * sizeof(struct engine));
@@ -242,6 +269,8 @@ static struct engines *discover_engines(void)
 			ret = errno;
 			break;
 		}
+
+		ret = 0;
 	}
 
 	if (ret) {
@@ -551,7 +580,7 @@ static uint64_t pmu_read_multi(int fd, unsigned int num, uint64_t *val)
 	return buf[1];
 }
 
-static double __pmu_calc(struct pmu_pair *p, double d, double t, double s)
+static double pmu_calc(struct pmu_pair *p, double d, double t, double s)
 {
 	double v;
 
@@ -576,30 +605,6 @@ static void fill_str(char *buf, unsigned int bufsz, char c, unsigned int num)
 	*buf = 0;
 }
 
-static void pmu_calc(struct pmu_counter *cnt,
-		     char *buf, unsigned int bufsz,
-		     unsigned int width, unsigned width_dec,
-		     double d, double t, double s)
-{
-	double val;
-	int len;
-
-	assert(bufsz >= (width + width_dec + 1));
-
-	if (!cnt->present) {
-		fill_str(buf, bufsz, '-', width + width_dec);
-		return;
-	}
-
-	val = __pmu_calc(&cnt->val, d, t, s);
-
-	len = snprintf(buf, bufsz, "%*.*f", width + width_dec, width_dec, val);
-	if (len < 0 || len == bufsz) {
-		fill_str(buf, bufsz, 'X', width + width_dec);
-		return;
-	}
-}
-
 static uint64_t __pmu_read_single(int fd, uint64_t *ts)
 {
 	uint64_t data[2] = { };
@@ -697,11 +702,552 @@ usage(const char *appname)
 		"\n"
 		"\tThe following parameters are optional:\n\n"
 		"\t[-s <ms>]       Refresh period in milliseconds (default %ums).\n"
+		"\t[-l]            List data to standard out.\n"
+		"\t[-J]            JSON data to standard out.\n"
 		"\t[-h]            Show this help text.\n"
 		"\n",
 		appname, DEFAULT_PERIOD_MS);
 }
 
+static enum {
+	INTERACTIVE,
+	STDOUT,
+	JSON
+} output_mode;
+
+struct cnt_item {
+	struct pmu_counter *pmu;
+	unsigned int fmt_d;
+	unsigned int fmt_dd;
+	double d;
+	double t;
+	double s;
+	const char *name;
+	const char *unit;
+
+	/* Internal fields. */
+	char buf[16];
+};
+
+struct cnt_group {
+	const char *name;
+	const char *display_name;
+	struct cnt_item *items;
+};
+
+static unsigned int json_indent_level;
+
+static const char *json_indent[] = {
+	"",
+	"\t",
+	"\t\t",
+	"\t\t\t",
+	"\t\t\t\t",
+	"\t\t\t\t\t",
+};
+
+#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
+
+static unsigned int json_prev_struct_members;
+static unsigned int json_struct_members;
+
+static void
+json_open_struct(const char *name)
+{
+	assert(json_indent_level < ARRAY_SIZE(json_indent));
+
+	json_prev_struct_members = json_struct_members;
+	json_struct_members = 0;
+
+	if (name)
+		printf("%s%s\"%s\": {\n",
+		       json_prev_struct_members ? ",\n" : "",
+		       json_indent[json_indent_level],
+		       name);
+	else
+		printf("%s\n%s{\n",
+		       json_prev_struct_members ? "," : "",
+		       json_indent[json_indent_level]);
+
+	json_indent_level++;
+}
+
+static void
+json_close_struct(void)
+{
+	assert(json_indent_level > 0);
+
+	printf("\n%s}", json_indent[--json_indent_level]);
+
+	if (json_indent_level == 0)
+		fflush(stdout);
+}
+
+static unsigned int
+json_add_member(const struct cnt_group *parent, struct cnt_item *item,
+		unsigned int headers)
+{
+	assert(json_indent_level < ARRAY_SIZE(json_indent));
+
+	printf("%s%s\"%s\": ",
+		json_struct_members ? ",\n" : "",
+		json_indent[json_indent_level], item->name);
+
+	json_struct_members++;
+
+	if (!strcmp(item->name, "unit"))
+		printf("\"%s\"", item->unit);
+	else
+		printf("%f",
+		       pmu_calc(&item->pmu->val, item->d, item->t, item->s));
+
+	return 1;
+}
+
+static unsigned int stdout_level;
+
+#define STDOUT_HEADER_REPEAT 20
+static unsigned int stdout_lines = STDOUT_HEADER_REPEAT;
+
+static void
+stdout_open_struct(const char *name)
+{
+	stdout_level++;
+	assert(stdout_level > 0);
+}
+
+static void
+stdout_close_struct(void)
+{
+	assert(stdout_level > 0);
+	if (--stdout_level == 0) {
+		stdout_lines++;
+		printf("\n");
+		fflush(stdout);
+	}
+}
+
+static unsigned int
+stdout_add_member(const struct cnt_group *parent, struct cnt_item *item,
+		  unsigned int headers)
+{
+	unsigned int fmt_tot = item->fmt_d + (item->fmt_dd ? 1 : 0);
+	char buf[fmt_tot + 1];
+	double val;
+	int len;
+
+	if (!item->pmu)
+		return 0;
+	else if (!item->pmu->present)
+		return 0;
+
+	if (headers == 1) {
+		unsigned int grp_tot = 0;
+		struct cnt_item *it;
+
+		if (item != parent->items)
+			return 0;
+
+		for (it = parent->items; it->pmu; it++) {
+			if (!it->pmu->present)
+				continue;
+
+			grp_tot += 1 + it->fmt_d + (it->fmt_dd ? 1 : 0);
+		}
+
+		printf("%*s ", grp_tot - 1, parent->display_name);
+		return 0;
+	} else if (headers == 2) {
+		printf("%*s ", fmt_tot, item->unit ?: item->name);
+		return 0;
+	}
+
+	val = pmu_calc(&item->pmu->val, item->d, item->t, item->s);
+
+	len = snprintf(buf, sizeof(buf), "%*.*f", fmt_tot, item->fmt_dd, val);
+	if (len < 0 || len == sizeof(buf))
+		fill_str(buf, sizeof(buf), 'X', fmt_tot);
+
+	len = printf("%s ", buf);
+
+	return len > 0 ? len : 0;
+}
+
+static void
+term_open_struct(const char *name)
+{
+}
+
+static void
+term_close_struct(void)
+{
+}
+
+static unsigned int
+term_add_member(const struct cnt_group *parent, struct cnt_item *item,
+		unsigned int headers)
+{
+	unsigned int fmt_tot = item->fmt_d + (item->fmt_dd ? 1 : 0);
+	double val;
+	int len;
+
+	if (!item->pmu)
+		return 0;
+
+	assert(fmt_tot <= sizeof(item->buf));
+
+	if (!item->pmu->present) {
+		fill_str(item->buf, sizeof(item->buf), '-', fmt_tot);
+		return 1;
+	}
+
+	val = pmu_calc(&item->pmu->val, item->d, item->t, item->s);
+	len = snprintf(item->buf, sizeof(item->buf),
+		       "%*.*f",
+		       fmt_tot, item->fmt_dd, val);
+
+	if (len < 0 || len == sizeof(item->buf))
+		fill_str(item->buf, sizeof(item->buf), 'X', fmt_tot);
+
+	return 1;
+}
+
+struct print_operations {
+	void (*open_struct)(const char *name);
+	void (*close_struct)(void);
+	unsigned int (*add_member)(const struct cnt_group *parent,
+				   struct cnt_item *item,
+				   unsigned int headers);
+	bool (*print_group)(struct cnt_group *group, unsigned int headers);
+};
+
+static const struct print_operations *pops;
+
+static unsigned int
+present_in_group(const struct cnt_group *grp)
+{
+	unsigned int present = 0;
+	struct cnt_item *item;
+
+	for (item = grp->items; item->name; item++) {
+		if (item->pmu && item->pmu->present)
+			present++;
+	}
+
+	return present;
+}
+
+static bool
+print_group(struct cnt_group *grp, unsigned int headers)
+{
+	unsigned int consumed = 0;
+	struct cnt_item *item;
+
+	if (!present_in_group(grp))
+		return false;
+
+	pops->open_struct(grp->name);
+
+	for (item = grp->items; item->name; item++)
+		consumed += pops->add_member(grp, item, headers);
+
+	pops->close_struct();
+
+	return consumed;
+}
+
+static bool
+term_print_group(struct cnt_group *grp, unsigned int headers)
+{
+	unsigned int consumed = 0;
+	struct cnt_item *item;
+
+	pops->open_struct(grp->name);
+
+	for (item = grp->items; item->name; item++)
+		consumed += pops->add_member(grp, item, headers);
+
+	pops->close_struct();
+
+	return consumed;
+}
+
+static const struct print_operations json_pops = {
+	.open_struct = json_open_struct,
+	.close_struct = json_close_struct,
+	.add_member = json_add_member,
+	.print_group = print_group,
+};
+
+static const struct print_operations stdout_pops = {
+	.open_struct = stdout_open_struct,
+	.close_struct = stdout_close_struct,
+	.add_member = stdout_add_member,
+	.print_group = print_group,
+};
+
+static const struct print_operations term_pops = {
+	.open_struct = term_open_struct,
+	.close_struct = term_close_struct,
+	.add_member = term_add_member,
+	.print_group = term_print_group,
+};
+
+static bool print_groups(struct cnt_group **groups)
+{
+	unsigned int headers = stdout_lines % STDOUT_HEADER_REPEAT + 1;
+	bool print_data = true;
+
+	if (output_mode == STDOUT && (headers == 1 || headers == 2)) {
+		for (struct cnt_group **grp = groups; *grp; grp++)
+			print_data = pops->print_group(*grp, headers);
+	}
+
+	for (struct cnt_group **grp = groups; print_data && *grp; grp++)
+		pops->print_group(*grp, false);
+
+	return print_data;
+}
+
+static int
+print_header(struct engines *engines, double t,
+	     int lines, int con_w, int con_h, bool *consumed)
+{
+	struct pmu_counter fake_pmu = {
+		.present = true,
+		.val.cur = 1,
+	};
+	struct cnt_item period_items[] = {
+		{ &fake_pmu, 0, 0, 1.0, 1.0, t * 1e3, "duration" },
+		{ NULL, 0, 0, 0.0, 0.0, 0.0, "unit", "ms" },
+		{ },
+	};
+	struct cnt_group period_group = {
+		.name = "period",
+		.items = period_items,
+	};
+	struct cnt_item freq_items[] = {
+		{ &engines->freq_req, 4, 0, 1.0, t, 1, "requested", "req" },
+		{ &engines->freq_act, 4, 0, 1.0, t, 1, "actual", "act" },
+		{ NULL, 0, 0, 0.0, 0.0, 0.0, "unit", "MHz" },
+		{ },
+	};
+	struct cnt_group freq_group = {
+		.name = "frequency",
+		.display_name = "Freq MHz",
+		.items = freq_items,
+	};
+	struct cnt_item irq_items[] = {
+		{ &engines->irq, 8, 0, 1.0, t, 1, "count", "/s" },
+		{ NULL, 0, 0, 0.0, 0.0, 0.0, "unit", "irq/s" },
+		{ },
+	};
+	struct cnt_group irq_group = {
+		.name = "interrupts",
+		.display_name = "IRQ",
+		.items = irq_items,
+	};
+	struct cnt_item rc6_items[] = {
+		{ &engines->rc6, 3, 0, 1e9, t, 100, "value", "%" },
+		{ NULL, 0, 0, 0.0, 0.0, 0.0, "unit", "%" },
+		{ },
+	};
+	struct cnt_group rc6_group = {
+		.name = "rc6",
+		.display_name = "RC6",
+		.items = rc6_items,
+	};
+	struct cnt_item power_items[] = {
+		{ &engines->rapl, 4, 2, 1.0, t, engines->rapl_scale, "value",
+		  "W" },
+		{ NULL, 0, 0, 0.0, 0.0, 0.0, "unit", "W" },
+		{ },
+	};
+	struct cnt_group power_group = {
+		.name = "power",
+		.display_name = "Power",
+		.items = power_items,
+	};
+	struct cnt_group *groups[] = {
+		&period_group,
+		&freq_group,
+		&irq_group,
+		&rc6_group,
+		&power_group,
+		NULL
+	};
+
+	if (output_mode != JSON)
+		memmove(&groups[0], &groups[1],
+			sizeof(groups) - sizeof(groups[0]));
+
+	pops->open_struct(NULL);
+
+	*consumed = print_groups(groups);
+
+	if (output_mode == INTERACTIVE) {
+		printf("\033[H\033[J");
+
+		if (lines++ < con_h)
+			printf("intel-gpu-top - %s/%s MHz;  %s%% RC6; %s %s; %s irqs/s\n",
+			       freq_items[1].buf, freq_items[0].buf,
+			       rc6_items[0].buf, power_items[0].buf,
+			       engines->rapl_unit,
+			       irq_items[0].buf);
+
+		if (lines++ < con_h)
+			printf("\n");
+	}
+
+	return lines;
+}
+
+static int
+print_imc(struct engines *engines, double t, int lines, int con_w, int con_h)
+{
+	struct cnt_item imc_items[] = {
+		{ &engines->imc_reads, 6, 0, 1.0, t, engines->imc_reads_scale,
+		  "reads", "rd" },
+		{ &engines->imc_writes, 6, 0, 1.0, t, engines->imc_writes_scale,
+		  "writes", "wr" },
+		{ NULL, 0, 0, 0.0, 0.0, 0.0, "unit" },
+		{ },
+	};
+	struct cnt_group imc_group = {
+		.name = "imc-bandwidth",
+		.items = imc_items,
+	};
+	struct cnt_group *groups[] = {
+		&imc_group,
+		NULL
+	};
+	int ret;
+
+	ret = asprintf((char **)&imc_group.display_name, "IMC %s/s",
+			engines->imc_reads_unit);
+	assert(ret >= 0);
+
+	ret = asprintf((char **)&imc_items[2].unit, "%s/s",
+			engines->imc_reads_unit);
+	assert(ret >= 0);
+
+	print_groups(groups);
+
+	free((void *)imc_group.display_name);
+	free((void *)imc_items[2].unit);
+
+	if (output_mode == INTERACTIVE) {
+		if (lines++ < con_h)
+			printf("      IMC reads:   %s %s/s\n",
+			       imc_items[0].buf, engines->imc_reads_unit);
+
+		if (lines++ < con_h)
+			printf("     IMC writes:   %s %s/s\n",
+			       imc_items[1].buf, engines->imc_writes_unit);
+
+		if (lines++ < con_h)
+			printf("\n");
+	}
+
+	return lines;
+}
+
+static int
+print_engines_header(struct engines *engines, double t,
+		     int lines, int con_w, int con_h)
+{
+	for (unsigned int i = 0;
+	     i < engines->num_engines && lines < con_h;
+	     i++) {
+		struct engine *engine = engine_ptr(engines, i);
+
+		if (!engine->num_counters)
+			continue;
+
+		pops->open_struct("engines");
+
+		if (output_mode == INTERACTIVE) {
+			const char *a = "          ENGINE      BUSY ";
+			const char *b = " MI_SEMA MI_WAIT";
+
+			printf("\033[7m%s%*s%s\033[0m\n",
+			       a, (int)(con_w - 1 - strlen(a) - strlen(b)),
+			       " ", b);
+
+			lines++;
+		}
+
+		break;
+	}
+
+	return lines;
+}
+
+static int
+print_engine(struct engines *engines, unsigned int i, double t,
+	     int lines, int con_w, int con_h)
+{
+	struct engine *engine = engine_ptr(engines, i);
+	struct cnt_item engine_items[] = {
+		{ &engine->busy, 6, 2, 1e9, t, 100, "busy", "%" },
+		{ &engine->sema, 3, 0, 1e9, t, 100, "sema", "se" },
+		{ &engine->wait, 3, 0, 1e9, t, 100, "wait", "wa" },
+		{ NULL, 0, 0, 0.0, 0.0, 0.0, "unit", "%" },
+		{ },
+	};
+	struct cnt_group engine_group = {
+		.name = engine->display_name,
+		.display_name = engine->short_name,
+		.items = engine_items,
+	};
+	struct cnt_group *groups[] = {
+		&engine_group,
+		NULL
+	};
+
+	if (!engine->num_counters)
+		return lines;
+
+	print_groups(groups);
+
+	if (output_mode == INTERACTIVE) {
+		unsigned int max_w = con_w - 1;
+		unsigned int len;
+		char buf[128];
+		double val;
+
+		len = snprintf(buf, sizeof(buf), "    %s%%    %s%%",
+			       engine_items[1].buf, engine_items[2].buf);
+
+		len += printf("%16s %s%% ",
+			      engine->display_name, engine_items[0].buf);
+
+		val = pmu_calc(&engine->busy.val, 1e9, t, 100);
+		print_percentage_bar(val, max_w - len);
+
+		printf("%s\n", buf);
+
+		lines++;
+	}
+
+	return lines;
+}
+
+static int
+print_engines_footer(struct engines *engines, double t,
+		     int lines, int con_w, int con_h)
+{
+	pops->close_struct();
+	pops->close_struct();
+
+	if (output_mode == INTERACTIVE) {
+		if (lines++ < con_h)
+			printf("\n");
+	}
+
+	return lines;
+}
+
 int main(int argc, char **argv)
 {
 	unsigned int period_us = DEFAULT_PERIOD_MS * 1000;
@@ -711,11 +1257,17 @@ int main(int argc, char **argv)
 	int ret, ch;
 
 	/* Parse options */
-	while ((ch = getopt(argc, argv, "s:h")) != -1) {
+	while ((ch = getopt(argc, argv, "s:Jlh")) != -1) {
 		switch (ch) {
 		case 's':
 			period_us = atoi(optarg) * 1000;
 			break;
+		case 'J':
+			output_mode = JSON;
+			break;
+		case 'l':
+			output_mode = STDOUT;
+			break;
 		case 'h':
 			usage(argv[0]);
 			exit(0);
@@ -726,6 +1278,24 @@ int main(int argc, char **argv)
 		}
 	}
 
+	if (output_mode == INTERACTIVE && isatty(1) != 1)
+		output_mode = STDOUT;
+
+	switch (output_mode) {
+	case INTERACTIVE:
+		pops = &term_pops;
+		break;
+	case STDOUT:
+		pops = &stdout_pops;
+		break;
+	case JSON:
+		pops = &json_pops;
+		break;
+	default:
+		assert(0);
+		break;
+	};
+
 	engines = discover_engines();
 	if (!engines) {
 		fprintf(stderr,
@@ -744,20 +1314,15 @@ int main(int argc, char **argv)
 	pmu_sample(engines);
 
 	for (;;) {
-		double t;
-#define BUFSZ 16
-		char freq[BUFSZ];
-		char fact[BUFSZ];
-		char irq[BUFSZ];
-		char rc6[BUFSZ];
-		char power[BUFSZ];
-		char reads[BUFSZ];
-		char writes[BUFSZ];
-		struct winsize ws;
+		bool consumed = false;
 		int lines = 0;
+		struct winsize ws;
+		double t;
 
 		/* Update terminal size. */
-		if (ioctl(0, TIOCGWINSZ, &ws) != -1) {
+		if (output_mode != INTERACTIVE) {
+			con_w = con_h = INT_MAX;
+		} else if (ioctl(0, TIOCGWINSZ, &ws) != -1) {
 			con_w = ws.ws_col;
 			con_h = ws.ws_row;
 		}
@@ -765,88 +1330,27 @@ int main(int argc, char **argv)
 		pmu_sample(engines);
 		t = (double)(engines->ts.cur - engines->ts.prev) / 1e9;
 
-		printf("\033[H\033[J");
-
-		pmu_calc(&engines->freq_req, freq, BUFSZ, 4, 0, 1.0, t, 1);
-		pmu_calc(&engines->freq_act, fact, BUFSZ, 4, 0, 1.0, t, 1);
-		pmu_calc(&engines->irq, irq, BUFSZ, 8, 0, 1.0, t, 1);
-		pmu_calc(&engines->rc6, rc6, BUFSZ, 3, 0, 1e9, t, 100);
-		pmu_calc(&engines->rapl, power, BUFSZ, 4, 2, 1.0, t,
-			 engines->rapl_scale);
-		pmu_calc(&engines->imc_reads, reads, BUFSZ, 6, 0, 1.0, t,
-			 engines->imc_reads_scale);
-		pmu_calc(&engines->imc_writes, writes, BUFSZ, 6, 0, 1.0, t,
-			 engines->imc_writes_scale);
-
-		if (lines++ < con_h)
-			printf("intel-gpu-top - %s/%s MHz;  %s%% RC6; %s %s; %s irqs/s\n",
-			       fact, freq, rc6, power, engines->rapl_unit, irq);
+		while (!consumed) {
+			lines = print_header(engines, t, lines, con_w, con_h,
+					     &consumed);
 
-		if (lines++ < con_h)
-			printf("\n");
+			if (engines->imc_fd)
+				lines = print_imc(engines, t, lines, con_w,
+						  con_h);
 
-		if (engines->imc_fd) {
-			if (lines++ < con_h)
-				printf("      IMC reads:   %s %s/s\n",
-				       reads, engines->imc_reads_unit);
+			lines = print_engines_header(engines, t, lines, con_w,
+						     con_h);
 
-			if (lines++ < con_h)
-				printf("     IMC writes:   %s %s/s\n",
-				       writes, engines->imc_writes_unit);
+			for (i = 0;
+			     i < engines->num_engines && lines < con_h;
+			     i++)
+				lines = print_engine(engines, i, t, lines,
+						     con_w, con_h);
 
-			if (++lines < con_h)
-				printf("\n");
+			lines = print_engines_footer(engines, t, lines, con_w,
+						     con_h);
 		}
 
-		for (i = 0; i < engines->num_engines; i++) {
-			struct engine *engine = engine_ptr(engines, i);
-
-			if (engine->num_counters && lines < con_h) {
-				const char *a = "          ENGINE      BUSY ";
-				const char *b = " MI_SEMA MI_WAIT";
-
-				printf("\033[7m%s%*s%s\033[0m\n",
-				       a,
-				       (int)(con_w - 1 - strlen(a) - strlen(b)),
-				       " ", b);
-				lines++;
-				break;
-			}
-		}
-
-		for (i = 0; i < engines->num_engines && lines < con_h; i++) {
-			struct engine *engine = engine_ptr(engines, i);
-			unsigned int max_w = con_w - 1;
-			unsigned int len;
-			char sema[BUFSZ];
-			char wait[BUFSZ];
-			char busy[BUFSZ];
-			char buf[128];
-			double val;
-
-			if (!engine->num_counters)
-				continue;
-
-			pmu_calc(&engine->sema, sema, BUFSZ, 3, 0, 1e9, t, 100);
-			pmu_calc(&engine->wait, wait, BUFSZ, 3, 0, 1e9, t, 100);
-			len = snprintf(buf, sizeof(buf), "    %s%%    %s%%",
-				       sema, wait);
-
-			pmu_calc(&engine->busy, busy, BUFSZ, 6, 2, 1e9, t,
-				 100);
-			len += printf("%16s %s%% ", engine->display_name, busy);
-
-			val = __pmu_calc(&engine->busy.val, 1e9, t, 100);
-			print_percentage_bar(val, max_w - len);
-
-			printf("%s\n", buf);
-
-			lines++;
-		}
-
-		if (lines++ < con_h)
-			printf("\n");
-
 		usleep(period_us);
 	}
 
-- 
2.19.1

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




[Index of Archives]     [AMD Graphics]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux