Skip to contentSkip to conversation

Per client GPU utilisation

PATCH In review Tvrtko Ursulin 3 participants 20 messages Feb 22, 2022 – Apr 1, 2022

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

cover Per client GPU utilisation

From: Tvrtko Ursulin <[email protected]>

This series contains four main components:

1. Per client support for intel_gpu_top.
2. IGT test for per client data exposed via fdinfo from i915.
3. Extracting intel_gpu_top code into shared IGT libraries - which makes possible to write:
4. Vendor agnostic rudimentary gputop tool.

Since I had the intel_gpu_top code for years, this flow of the series is what I ended up with. But it also makes sense since we can have a cut point after intel_gpu_top, in case the common drm fdinfo specification does not end up getting enough traction.

Example of the intel_gpu_top output:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
intel-gpu-top: Intel Tigerlake (Gen12) @ /dev/dri/card0 - 220/ 221 MHz
70% RC6; 0.62/ 7.08 W; 760 irqs/s

ENGINES BUSY MI_SEMA MI_WAIT
Render/3D 23.06% |██████▊ | 0% 0%
Blitter 0.00% | | 0% 0%
Video 5.40% |█▋ | 0% 0%
VideoEnhance 20.67% |██████ | 0% 0%

PID NAME Render/3D Blitter Video VideoEnhance

  3082               mpv |          ||          ||▌         ||██        |
  3117         neverball |█▉        ||          ||          ||          |
     1           systemd |▍         ||          ||          ||          |
  2338       gnome-shell |          ||          ||          ||          |

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Example of the gputop output:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
DRM minor 0

    PID               NAME    render       copy       video
    3816          kwin_x11 |███▎      ||          ||          ||          |
    3523              Xorg |▊         ||          ||          ||          |
 1120449               mpv |          ||          ||▋         ||          |
 1120529          glxgears |▋         ||          ||          ||          |
 1120449               mpv |▍         ||          ||          ||          |
    3860       plasmashell |▏         ||          ||          ||          |
    4764           krunner |          ||          ||          ||          |
  575206            chrome |          ||          ||          ||          |
  833481           firefox |          ||          ||          ||          |
  892924       thunderbird |          ||          ||          ||          |

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Tvrtko Ursulin (11):
lib: Helper library for parsing i915 fdinfo output tests/i915/drm_fdinfo: Basic and functional tests for GPU busyness
exported via fdinfo
intel-gpu-top: Add support for per client stats
lib: Extract igt_drm_clients from intel_gpu_top
libdrmfdinfo: Allow specifying custom engine map
libdrmclients: Record client drm minor
libdrmclient: Support multiple DRM cards
libdrmfdinfo: Track largest engine index libdrmclient/intel_gpu_top: Decouple hardcoded engine assumptions
libdrmclient: Enforce client status sort order in the library
gputop: Basic vendor agnostic GPU top tool

 lib/igt_drm_clients.c   | 443 +++++++++++++++++++++++++++++++
 lib/igt_drm_clients.h   | 104 ++++++++
 lib/igt_drm_fdinfo.c    | 200 ++++++++++++++
 lib/igt_drm_fdinfo.h    |  52 ++++
 lib/meson.build         |  15 ++
 man/intel_gpu_top.rst   |   4 +
 tests/i915/drm_fdinfo.c | 565 ++++++++++++++++++++++++++++++++++++++++
 tests/meson.build       |   8 +
 tools/gputop.c          | 276 ++++++++++++++++++++
 tools/intel_gpu_top.c   | 497 ++++++++++++++++++++++++++++++++++-
 tools/meson.build       |   7 +-
 11 files changed, 2159 insertions(+), 12 deletions(-)
 create mode 100644 lib/igt_drm_clients.c
 create mode 100644 lib/igt_drm_clients.h
 create mode 100644 lib/igt_drm_fdinfo.c
 create mode 100644 lib/igt_drm_fdinfo.h
 create mode 100644 tests/i915/drm_fdinfo.c
 create mode 100644 tools/gputop.c
Signature · 1 line
2.32.0
#1 lore raw

PATCH 1/11 lib: Helper library for parsing i915 fdinfo output

From: Tvrtko Ursulin <[email protected]>

Tests and intel_gpu_top will share common code for parsing this file.

---
 lib/igt_drm_fdinfo.c | 183 +++++++++++++++++++++++++++++++++++++++++++
 lib/igt_drm_fdinfo.h |  48 ++++++++++++
 lib/meson.build      |   7 ++
 3 files changed, 238 insertions(+)
 create mode 100644 lib/igt_drm_fdinfo.c
 create mode 100644 lib/igt_drm_fdinfo.h
lib/igt_drm_fdinfo.c new file +183 -0
new file mode 100644
index 000000000000..28c1bdbda08e
@@ -0,0 +1,183 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ *
+ */
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "drmtest.h"
+
+#include "igt_drm_fdinfo.h"
+
+static size_t read_fdinfo(char *buf, const size_t sz, int at, const char *name)
+{
+	size_t count;
+	int fd;
+
+	fd = openat(at, name, O_RDONLY);
+	if (fd < 0)
+		return 0;
+
+	buf[sz - 1] = 0;
+	count = read(fd, buf, sz);
+	close(fd);
+
+	return count;
+}
+
+static int parse_engine(char *line, struct drm_client_fdinfo *info,
+			size_t prefix_len, uint64_t *val)
+{
+	static const char *e2class[] = {
+		"render",
+		"copy",
+		"video",
+		"video-enhance",
+	};
+	ssize_t name_len;
+	char *name, *p;
+	int found = -1;
+	unsigned int i;
+
+	p = index(line, ':');
+	if (!p || p == line)
+		return -1;
+
+	name_len = p - line - prefix_len;
+	if (name_len < 1)
+		return -1;
+
+	name = line + prefix_len;
+
+	for (i = 0; i < ARRAY_SIZE(e2class); i++) {
+		if (!strncmp(name, e2class[i], name_len)) {
+			found = i;
+			break;
+		}
+	}
+
+	if (found >= 0) {
+		while (*++p && isspace(*p));
+		*val = strtoull(p, NULL, 10);
+	}
+
+	return found;
+}
+
+static const char *find_kv(const char *buf, const char *key, size_t keylen)
+{
+	const char *p = buf;
+
+	p = index(buf, ':');
+	if (!p || p == buf)
+		return NULL;
+
+	if ((p - buf) != keylen)
+		return NULL;
+
+	while (*++p && isspace(*p));
+	if (*p && !strncmp(buf, key, keylen))
+		return p;
+
+	return NULL;
+}
+
+bool
+__igt_parse_drm_fdinfo(int dir, const char *fd, struct drm_client_fdinfo *info)
+{
+	char buf[4096], *_buf = buf;
+	char *l, *ctx = NULL;
+	unsigned int good = 0;
+	size_t count;
+
+	count = read_fdinfo(buf, sizeof(buf), dir, fd);
+	if (!count)
+		return false;
+
+	while ((l = strtok_r(_buf, "\n", &ctx))) {
+		uint64_t val = 0;
+		const char *v;
+		int idx;
+
+		_buf = NULL;
+
+		if ((v = find_kv(l, "drm-driver", strlen("drm-driver")))) {
+			strncpy(info->driver, v, sizeof(info->driver) - 1);
+			good++;
+		} else if ((v = find_kv(l, "drm-pdev", strlen("drm-pdev")))) {
+			strncpy(info->pdev, v, sizeof(info->pdev) - 1);
+		}  else if ((v = find_kv(l, "drm-client-id",
+					 strlen("drm-client-id")))) {
+			info->id = atol(v);
+			good++;
+		} else if (!strncmp(l, "drm-engine-", 11) &&
+			   strncmp(l, "drm-engine-capacity-", 20)) {
+			idx = parse_engine(l, info, strlen("drm-engine-"),
+					   &val);
+			if (idx >= 0) {
+				if (!info->capacity[idx])
+					info->capacity[idx] = 1;
+				info->busy[idx] = val;
+				info->num_engines++;
+			}
+		} else if (!strncmp(l, "drm-engine-capacity-", 20)) {
+			idx = parse_engine(l, info,
+					   strlen("drm-engine-capacity-"),
+					   &val);
+			if (idx >= 0)
+				info->capacity[idx] = val;
+		}
+	}
+
+	if (good < 2 || !info->num_engines)
+		return false; /* fdinfo format not as expected */
+
+	return true;
+}
+
+bool igt_parse_drm_fdinfo(int drm_fd, struct drm_client_fdinfo *info)
+{
+	char fd[64];
+	int dir, ret;
+	bool res;
+
+	ret = snprintf(fd, sizeof(fd), "%u", drm_fd);
+	if (ret < 0 || ret == sizeof(fd))
+		return false;
+
+	dir = open("/proc/self/fdinfo", O_DIRECTORY | O_RDONLY);
+	if (dir < 0)
+		return false;
+
+	res = __igt_parse_drm_fdinfo(dir, fd, info);
+
+	close(dir);
+
+	return res;
+}
lib/igt_drm_fdinfo.h new file +48 -0

48 lines not on this page · raw message

lib/meson.build +7 -0
index 3e43316d1e36..d00817dc58bc 100644
@@ -16,6 +16,7 @@ lib_sources = [
 	'igt_debugfs.c',
 	'igt_device.c',
 	'igt_device_scan.c',
+	'igt_drm_fdinfo.c',
 	'igt_aux.c',
 	'igt_gt.c',
 	'igt_halffloat.c',
@@ -216,6 +217,12 @@ lib_igt_device_scan_build = static_library('igt_device_scan',
 lib_igt_device_scan = declare_dependency(link_with : lib_igt_device_scan_build,
 				  include_directories : inc)
 
+lib_igt_drm_fdinfo_build = static_library('igt_drm_fdinfo',
+	['igt_drm_fdinfo.c'],
+	include_directories : inc)
+
+lib_igt_drm_fdinfo = declare_dependency(link_with : lib_igt_drm_fdinfo_build,
+				  include_directories : inc)
 i915_perf_files = [
   'igt_list.c',
   'i915/perf.c',
Signature · 1 line
2.32.0
#2 lore raw

Re: [Intel-gfx] [PATCH i-g-t 01/11] lib: Helper library for parsing i915 fdinfo output

Quoted 56 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Tests and intel_gpu_top will share common code for parsing this file.

---

lib/igt_drm_fdinfo.c | 183 +++++++++++++++++++++++++++++++++++++++++++
lib/igt_drm_fdinfo.h |  48 ++++++++++++
lib/meson.build      |   7 ++
3 files changed, 238 insertions(+)

create mode 100644 lib/igt_drm_fdinfo.c
create mode 100644 lib/igt_drm_fdinfo.h

lib/igt_drm_fdinfo.c new file +37 -0
new file mode 100644
index 000000000000..28c1bdbda08e
@@ -0,0 +1,183 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ *
+ */
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "drmtest.h"
+
+#include "igt_drm_fdinfo.h"
+

lib/igt_drm_fdinfo.c line 47

Quoted 10 lines
lib/igt_drm_fdinfo.c new file +10 -0
+static size_t read_fdinfo(char *buf, const size_t sz, int at, const char *name)
+{
+	size_t count;
+	int fd;
+
+	fd = openat(at, name, O_RDONLY);
+	if (fd < 0)
+		return 0;
+
+	buf[sz - 1] = 0;

Wondering if this ^ should be after the read() in case 4096 bytes are read.

Quoted 48 lines
lib/igt_drm_fdinfo.c new file +48 -0
+	count = read(fd, buf, sz);
+	close(fd);
+
+	return count;
+}
+
+static int parse_engine(char *line, struct drm_client_fdinfo *info,
+			size_t prefix_len, uint64_t *val)
+{
+	static const char *e2class[] = {
+		"render",
+		"copy",
+		"video",
+		"video-enhance",
+	};
+	ssize_t name_len;
+	char *name, *p;
+	int found = -1;
+	unsigned int i;
+
+	p = index(line, ':');
+	if (!p || p == line)
+		return -1;
+
+	name_len = p - line - prefix_len;
+	if (name_len < 1)
+		return -1;
+
+	name = line + prefix_len;
+
+	for (i = 0; i < ARRAY_SIZE(e2class); i++) {
+		if (!strncmp(name, e2class[i], name_len)) {
+			found = i;
+			break;
+		}
+	}
+
+	if (found >= 0) {
+		while (*++p && isspace(*p));
+		*val = strtoull(p, NULL, 10);
+	}
+
+	return found;
+}
+
+static const char *find_kv(const char *buf, const char *key, size_t keylen)
+{
+	const char *p = buf;

lib/igt_drm_fdinfo.c line 105

Quoted 10 lines
lib/igt_drm_fdinfo.c new file +10 -0
+
+	p = index(buf, ':');
+	if (!p || p == buf)
+		return NULL;
+
+	if ((p - buf) != keylen)
+		return NULL;
+
+	while (*++p && isspace(*p));
+	if (*p && !strncmp(buf, key, keylen))

nit: why not just do the strncmp early in this function since buf, key, keylen have not changed?

lib/igt_drm_fdinfo.c line 118

Quoted 13 lines
lib/igt_drm_fdinfo.c new file +13 -0
+		return p;
+
+	return NULL;
+}
+
+bool
+__igt_parse_drm_fdinfo(int dir, const char *fd, struct drm_client_fdinfo *info)
+{
+	char buf[4096], *_buf = buf;
+	char *l, *ctx = NULL;
+	unsigned int good = 0;
+	size_t count;
+

Should buf be zeroed out here?

Quoted 101 lines
lib/igt_drm_fdinfo.c new file +65 -0
+	count = read_fdinfo(buf, sizeof(buf), dir, fd);
+	if (!count)
+		return false;
+
+	while ((l = strtok_r(_buf, "\n", &ctx))) {
+		uint64_t val = 0;
+		const char *v;
+		int idx;
+
+		_buf = NULL;
+
+		if ((v = find_kv(l, "drm-driver", strlen("drm-driver")))) {
+			strncpy(info->driver, v, sizeof(info->driver) - 1);
+			good++;
+		} else if ((v = find_kv(l, "drm-pdev", strlen("drm-pdev")))) {
+			strncpy(info->pdev, v, sizeof(info->pdev) - 1);
+		}  else if ((v = find_kv(l, "drm-client-id",
+					 strlen("drm-client-id")))) {
+			info->id = atol(v);
+			good++;
+		} else if (!strncmp(l, "drm-engine-", 11) &&
+			   strncmp(l, "drm-engine-capacity-", 20)) {
+			idx = parse_engine(l, info, strlen("drm-engine-"),
+					   &val);
+			if (idx >= 0) {
+				if (!info->capacity[idx])
+					info->capacity[idx] = 1;
+				info->busy[idx] = val;
+				info->num_engines++;
+			}
+		} else if (!strncmp(l, "drm-engine-capacity-", 20)) {
+			idx = parse_engine(l, info,
+					   strlen("drm-engine-capacity-"),
+					   &val);
+			if (idx >= 0)
+				info->capacity[idx] = val;
+		}
+	}
+
+	if (good < 2 || !info->num_engines)
+		return false; /* fdinfo format not as expected */
+
+	return true;
+}
+
+bool igt_parse_drm_fdinfo(int drm_fd, struct drm_client_fdinfo *info)
+{
+	char fd[64];
+	int dir, ret;
+	bool res;
+
+	ret = snprintf(fd, sizeof(fd), "%u", drm_fd);
+	if (ret < 0 || ret == sizeof(fd))
+		return false;
+
+	dir = open("/proc/self/fdinfo", O_DIRECTORY | O_RDONLY);
+	if (dir < 0)
+		return false;
+
+	res = __igt_parse_drm_fdinfo(dir, fd, info);
+
+	close(dir);
+
+	return res;
+}
lib/igt_drm_fdinfo.h new file +30 -0
new file mode 100644
index 000000000000..c527bab9a204
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ *
+ */
+
+#ifndef IGT_DRM_FDINFO_H
+#define IGT_DRM_FDINFO_H
+
+#include <sys/types.h>
+#include <dirent.h>
+#include <stdint.h>

lib/igt_drm_fdinfo.h line 40

Quoted 10 lines
lib/igt_drm_fdinfo.h new file +10 -0
+#include <stdbool.h>
+
+struct drm_client_fdinfo {
+	char driver[128];
+	char pdev[128];
+	unsigned long id;
+
+	unsigned int num_engines;
+	unsigned int capacity[16];
+	uint64_t busy[16];

I see 16 in a lot of places, wondering if it could use a #define?

Thanks,
Umesh

Quoted 36 lines
lib/igt_drm_fdinfo.h new file +8 -0
+};
+
+bool igt_parse_drm_fdinfo(int drm_fd, struct drm_client_fdinfo *info);
+
+bool __igt_parse_drm_fdinfo(int dir, const char *fd,
+			    struct drm_client_fdinfo *info);
+
+#endif /* IGT_DRM_FDINFO_H */
lib/meson.build +7 -0
index 3e43316d1e36..d00817dc58bc 100644
@@ -16,6 +16,7 @@ lib_sources = [
 	'igt_debugfs.c',
 	'igt_device.c',
 	'igt_device_scan.c',
+	'igt_drm_fdinfo.c',
 	'igt_aux.c',
 	'igt_gt.c',
 	'igt_halffloat.c',
@@ -216,6 +217,12 @@ lib_igt_device_scan_build = static_library('igt_device_scan',
 lib_igt_device_scan = declare_dependency(link_with : lib_igt_device_scan_build,
 				  include_directories : inc)
 
+lib_igt_drm_fdinfo_build = static_library('igt_drm_fdinfo',
+	['igt_drm_fdinfo.c'],
+	include_directories : inc)
+
+lib_igt_drm_fdinfo = declare_dependency(link_with : lib_igt_drm_fdinfo_build,
+				  include_directories : inc)

i915_perf_files = [
'igt_list.c',
'i915/perf.c',

Signature · 1 line
2.32.0
#3 lore raw

Re: [Intel-gfx] [PATCH i-g-t 01/11] lib: Helper library for parsing i915 fdinfo output

Quoted 74 lines · Umesh Nerlige Ramappa
Quoted 73 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Tests and intel_gpu_top will share common code for parsing this file.

---
lib/igt_drm_fdinfo.c | 183 +++++++++++++++++++++++++++++++++++++++++++ lib/igt_drm_fdinfo.h |  48 ++++++++++++
lib/meson.build      |   7 ++

3 files changed, 238 insertions(+)

create mode 100644 lib/igt_drm_fdinfo.c
create mode 100644 lib/igt_drm_fdinfo.h

lib/igt_drm_fdinfo.c new file +4 -0
new file mode 100644
index 000000000000..28c1bdbda08e
@@ -0,0 +1,183 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person 

obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ *
+ */

lib/igt_drm_fdinfo.c new file +15 -0
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "drmtest.h"
+
+#include "igt_drm_fdinfo.h"
+
+static size_t read_fdinfo(char *buf, const size_t sz, int at, const 

char *name)
+{
+    size_t count;
+    int fd;

Quoted 8 lines

lib/igt_drm_fdinfo.c line 47

Quoted 6 lines
lib/igt_drm_fdinfo.c new file +6 -0
+
+    fd = openat(at, name, O_RDONLY);
+    if (fd < 0)
+        return 0;
+
+    buf[sz - 1] = 0;

Wondering if this ^ should be after the read() in case 4096 bytes are read.

Yes, I guess even before and after so it's guaranteed to be null terminated no matter what.

Quoted 54 lines
Quoted 54 lines

+    count = read(fd, buf, sz);
+    close(fd);

lib/igt_drm_fdinfo.c new file +44 -0
+
+    return count;
+}
+
+static int parse_engine(char *line, struct drm_client_fdinfo *info,
+            size_t prefix_len, uint64_t *val)
+{
+    static const char *e2class[] = {
+        "render",
+        "copy",
+        "video",
+        "video-enhance",
+    };
+    ssize_t name_len;
+    char *name, *p;
+    int found = -1;
+    unsigned int i;
+
+    p = index(line, ':');
+    if (!p || p == line)
+        return -1;
+
+    name_len = p - line - prefix_len;
+    if (name_len < 1)
+        return -1;
+
+    name = line + prefix_len;
+
+    for (i = 0; i < ARRAY_SIZE(e2class); i++) {
+        if (!strncmp(name, e2class[i], name_len)) {
+            found = i;
+            break;
+        }
+    }
+
+    if (found >= 0) {
+        while (*++p && isspace(*p));
+        *val = strtoull(p, NULL, 10);
+    }
+
+    return found;
+}
+
+static const char *find_kv(const char *buf, const char *key, size_t 

keylen)

lib/igt_drm_fdinfo.c new file +6 -0
+{
+    const char *p = buf;
+
+    p = index(buf, ':');
+    if (!p || p == buf)
+        return NULL;
Quoted 8 lines

lib/igt_drm_fdinfo.c line 105

Quoted 6 lines
lib/igt_drm_fdinfo.c new file +6 -0
+
+    if ((p - buf) != keylen)
+        return NULL;
+
+    while (*++p && isspace(*p));
+    if (*p && !strncmp(buf, key, keylen))

nit: why not just do the strncmp early in this function since buf, key, keylen have not changed?

I see what you mean, first check that the key/prefix matches and do the other checks, right?

I honestly don't remember if there was a special reason why I laid it out like it is. I know it is an annoyingly hot path and I did do many tweaks to bring the CPU utilisation low.

But thinking about it now, the strncmp at the start should indeed be more efficient so I will change it.

Quoted 17 lines
Quoted 9 lines

+        return p;

lib/igt_drm_fdinfo.c new file +6 -0
+
+    return NULL;
+}
+
+bool
+__igt_parse_drm_fdinfo(int dir, const char *fd, struct 

drm_client_fdinfo *info)

lib/igt_drm_fdinfo.c line 118

Quoted 6 lines
lib/igt_drm_fdinfo.c new file +6 -0
+{
+    char buf[4096], *_buf = buf;
+    char *l, *ctx = NULL;
+    unsigned int good = 0;
+    size_t count;
+

Should buf be zeroed out here?

Right, either here or in read_fdinfo as mentioned above.

Quoted 117 lines
Quoted 117 lines

+    count = read_fdinfo(buf, sizeof(buf), dir, fd); +    if (!count)
+        return false;

lib/igt_drm_fdinfo.c new file +62 -0
+
+    while ((l = strtok_r(_buf, "\n", &ctx))) {
+        uint64_t val = 0;
+        const char *v;
+        int idx;
+
+        _buf = NULL;
+
+        if ((v = find_kv(l, "drm-driver", strlen("drm-driver")))) {
+            strncpy(info->driver, v, sizeof(info->driver) - 1);
+            good++;
+        } else if ((v = find_kv(l, "drm-pdev", strlen("drm-pdev")))) {
+            strncpy(info->pdev, v, sizeof(info->pdev) - 1);
+        }  else if ((v = find_kv(l, "drm-client-id",
+                     strlen("drm-client-id")))) {
+            info->id = atol(v);
+            good++;
+        } else if (!strncmp(l, "drm-engine-", 11) &&
+               strncmp(l, "drm-engine-capacity-", 20)) {
+            idx = parse_engine(l, info, strlen("drm-engine-"),
+                       &val);
+            if (idx >= 0) {
+                if (!info->capacity[idx])
+                    info->capacity[idx] = 1;
+                info->busy[idx] = val;
+                info->num_engines++;
+            }
+        } else if (!strncmp(l, "drm-engine-capacity-", 20)) {
+            idx = parse_engine(l, info,
+                       strlen("drm-engine-capacity-"),
+                       &val);
+            if (idx >= 0)
+                info->capacity[idx] = val;
+        }
+    }
+
+    if (good < 2 || !info->num_engines)
+        return false; /* fdinfo format not as expected */
+
+    return true;
+}
+
+bool igt_parse_drm_fdinfo(int drm_fd, struct drm_client_fdinfo *info)
+{
+    char fd[64];
+    int dir, ret;
+    bool res;
+
+    ret = snprintf(fd, sizeof(fd), "%u", drm_fd);
+    if (ret < 0 || ret == sizeof(fd))
+        return false;
+
+    dir = open("/proc/self/fdinfo", O_DIRECTORY | O_RDONLY);
+    if (dir < 0)
+        return false;
+
+    res = __igt_parse_drm_fdinfo(dir, fd, info);
+
+    close(dir);
+
+    return res;
+}
lib/igt_drm_fdinfo.h new file +4 -0
new file mode 100644
index 000000000000..c527bab9a204
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person 

obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ *
+ */

lib/igt_drm_fdinfo.h new file +11 -0
+
+#ifndef IGT_DRM_FDINFO_H
+#define IGT_DRM_FDINFO_H
+
+#include <sys/types.h>
+#include <dirent.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+struct drm_client_fdinfo {
+    char driver[128];
Quoted 8 lines
Quoted 6 lines

+    char pdev[128];
+    unsigned long id;
+
+    unsigned int num_engines;
+    unsigned int capacity[16];
+    uint64_t busy[16];

I see 16 in a lot of places, wondering if it could use a #define?

I can see them here and one mention in igt_drm_clients. The latter it looks I can un-export igt_drm_client_update and make it take struct drm_client_fdinfo to better hide this.

And for here I will add a define like DRM_CLIENT_FDINFO_MAX_ENGINES.

Regards,

Tvrtko

Quoted 42 lines

Thanks,
Umesh

Quoted 38 lines
lib/igt_drm_fdinfo.h new file +8 -0
+};
+
+bool igt_parse_drm_fdinfo(int drm_fd, struct drm_client_fdinfo *info);
+
+bool __igt_parse_drm_fdinfo(int dir, const char *fd,
+                struct drm_client_fdinfo *info);
+
+#endif /* IGT_DRM_FDINFO_H */
lib/meson.build +7 -0
index 3e43316d1e36..d00817dc58bc 100644
@@ -16,6 +16,7 @@ lib_sources = [
     'igt_debugfs.c',
     'igt_device.c',
     'igt_device_scan.c',
+    'igt_drm_fdinfo.c',
     'igt_aux.c',
     'igt_gt.c',
     'igt_halffloat.c',
@@ -216,6 +217,12 @@ lib_igt_device_scan_build = 
 static_library('igt_device_scan',
 lib_igt_device_scan = declare_dependency(link_with : lib_igt_device_scan_build,
                   include_directories : inc)
 
+lib_igt_drm_fdinfo_build = static_library('igt_drm_fdinfo',
+    ['igt_drm_fdinfo.c'],
+    include_directories : inc)
+
+lib_igt_drm_fdinfo = declare_dependency(link_with : 
 lib_igt_drm_fdinfo_build,
+                  include_directories : inc)

i915_perf_files = [
  'igt_list.c',
  'i915/perf.c',

Signature · 1 line
2.32.0
#4 lore raw

PATCH 2/11 tests/i915/drm_fdinfo: Basic and functional tests for GPU busyness exported via fdinfo

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Mostly inherited from the perf_pmu, some basic tests, and some tests to verify exported GPU busyness is as expected.

---
 tests/i915/drm_fdinfo.c | 555 ++++++++++++++++++++++++++++++++++++++++
 tests/meson.build       |   8 +
 2 files changed, 563 insertions(+)
 create mode 100644 tests/i915/drm_fdinfo.c
tests/i915/drm_fdinfo.c new file +555 -0
new file mode 100644
index 000000000000..e3b1ebb0f454
@@ -0,0 +1,555 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ *
+ */
+
+#include "igt.h"
+#include "igt_core.h"
+#include "igt_device.h"
+#include "igt_drm_fdinfo.h"
+#include "i915/gem.h"
+#include "intel_ctx.h"
+
+IGT_TEST_DESCRIPTION("Test the i915 drm fdinfo data");
+
+const double tolerance = 0.05f;
+const unsigned long batch_duration_ns = 500e6;
+
+#define __assert_within_epsilon(x, ref, tol_up, tol_down) \
+	igt_assert_f((double)(x) <= (1.0 + (tol_up)) * (double)(ref) && \
+		     (double)(x) >= (1.0 - (tol_down)) * (double)(ref), \
+		     "'%s' != '%s' (%f not within +%.1f%%/-%.1f%% tolerance of %f)\n",\
+		     #x, #ref, (double)(x), \
+		     (tol_up) * 100.0, (tol_down) * 100.0, \
+		     (double)(ref))
+
+#define assert_within_epsilon(x, ref, tolerance) \
+	__assert_within_epsilon(x, ref, tolerance, tolerance)
+
+static void basics(int i915, unsigned int num_classes)
+{
+	struct drm_client_fdinfo info = { };
+	bool ret;
+
+	ret = igt_parse_drm_fdinfo(i915, &info);
+	igt_assert(ret);
+
+	igt_assert(!strcmp(info.driver, "i915"));
+
+	igt_assert_eq(info.num_engines, num_classes);
+}
+
+/*
+ * Helper for cases where we assert on time spent sleeping (directly or
+ * indirectly), so make it more robust by ensuring the system sleep time
+ * is within test tolerance to start with.
+ */
+static unsigned int measured_usleep(unsigned int usec)
+{
+	struct timespec ts = { };
+	unsigned int slept;
+
+	slept = igt_nsec_elapsed(&ts);
+	igt_assert(slept == 0);
+	do {
+		usleep(usec - slept);
+		slept = igt_nsec_elapsed(&ts) / 1000;
+	} while (slept < usec);
+
+	return igt_nsec_elapsed(&ts);
+}
+
+#define TEST_BUSY (1)
+#define FLAG_SYNC (2)
+#define TEST_TRAILING_IDLE (4)
+#define FLAG_HANG (8)
+#define TEST_ISOLATION (16)
+
+static igt_spin_t *__spin_poll(int fd, uint64_t ahnd, const intel_ctx_t *ctx,
+			       const struct intel_execution_engine2 *e)
+{
+	struct igt_spin_factory opts = {
+		.ahnd = ahnd,
+		.ctx = ctx,
+		.engine = e->flags,
+	};
+
+	if (gem_class_can_store_dword(fd, e->class))
+		opts.flags |= IGT_SPIN_POLL_RUN;
+
+	return __igt_spin_factory(fd, &opts);
+}
+
+static unsigned long __spin_wait(int fd, igt_spin_t *spin)
+{
+	struct timespec start = { };
+
+	igt_nsec_elapsed(&start);
+
+	if (igt_spin_has_poll(spin)) {
+		unsigned long timeout = 0;
+
+		while (!igt_spin_has_started(spin)) {
+			unsigned long t = igt_nsec_elapsed(&start);
+
+			igt_assert(gem_bo_busy(fd, spin->handle));
+			if ((t - timeout) > 250e6) {
+				timeout = t;
+				igt_warn("Spinner not running after %.2fms\n",
+					 (double)t / 1e6);
+				igt_assert(t < 2e9);
+			}
+		}
+	} else {
+		igt_debug("__spin_wait - usleep mode\n");
+		usleep(500e3); /* Better than nothing! */
+	}
+
+	igt_assert(gem_bo_busy(fd, spin->handle));
+	return igt_nsec_elapsed(&start);
+}
+
+static igt_spin_t *__spin_sync(int fd, uint64_t ahnd, const intel_ctx_t *ctx,
+			       const struct intel_execution_engine2 *e)
+{
+	igt_spin_t *spin = __spin_poll(fd, ahnd, ctx, e);
+
+	__spin_wait(fd, spin);
+
+	return spin;
+}
+
+static igt_spin_t *spin_sync(int fd, uint64_t ahnd, const intel_ctx_t *ctx,
+			     const struct intel_execution_engine2 *e)
+{
+	igt_require_gem(fd);
+
+	return __spin_sync(fd, ahnd, ctx, e);
+}
+
+static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
+{
+	if (!spin)
+		return;
+
+	igt_spin_end(spin);
+
+	if (flags & FLAG_SYNC)
+		gem_sync(fd, spin->handle);
+
+	if (flags & TEST_TRAILING_IDLE) {
+		unsigned long t, timeout = 0;
+		struct timespec start = { };
+
+		igt_nsec_elapsed(&start);
+
+		do {
+			t = igt_nsec_elapsed(&start);
+
+			if (gem_bo_busy(fd, spin->handle) &&
+			    (t - timeout) > 10e6) {
+				timeout = t;
+				igt_warn("Spinner not idle after %.2fms\n",
+					 (double)t / 1e6);
+			}
+
+			usleep(1e3);
+		} while (t < batch_duration_ns / 5);
+	}
+}
+
+static uint64_t read_busy(int i915, unsigned int class)
+{
+	struct drm_client_fdinfo info = { };
+
+	igt_assert(igt_parse_drm_fdinfo(i915, &info));
+
+	return info.busy[class];
+}
+
+static void
+single(int gem_fd, const intel_ctx_t *ctx,
+       const struct intel_execution_engine2 *e, unsigned int flags)
+{
+	unsigned long slept;
+	igt_spin_t *spin;
+	uint64_t val;
+	int spin_fd;
+	uint64_t ahnd;
+
+	if (flags & TEST_ISOLATION) {
+		spin_fd = gem_reopen_driver(gem_fd);
+		ctx = intel_ctx_create_all_physical(spin_fd);
+	} else {
+		spin_fd = gem_fd;
+	}
+
+	ahnd = get_reloc_ahnd(spin_fd, ctx->id);
+
+	if (flags & TEST_BUSY)
+		spin = spin_sync(spin_fd, ahnd, ctx, e);
+	else
+		spin = NULL;
+
+	val = read_busy(gem_fd, e->class);
+	slept = measured_usleep(batch_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(spin_fd, spin, flags);
+	val = read_busy(gem_fd, e->class) - val;
+
+	if (flags & FLAG_HANG)
+		igt_force_gpu_reset(spin_fd);
+	else
+		end_spin(spin_fd, spin, FLAG_SYNC);
+
+	assert_within_epsilon(val,
+			      (flags & TEST_BUSY) && !(flags & TEST_ISOLATION) ?
+			      slept : 0.0f,
+			      tolerance);
+
+	/* Check for idle after hang. */
+	if (flags & FLAG_HANG) {
+		gem_quiescent_gpu(spin_fd);
+		igt_assert(!gem_bo_busy(spin_fd, spin->handle));
+
+		val = read_busy(gem_fd, e->class);
+		slept = measured_usleep(batch_duration_ns / 1000);
+		val = read_busy(gem_fd, e->class) - val;
+
+		assert_within_epsilon(val, 0, tolerance);
+	}
+
+	igt_spin_free(spin_fd, spin);
+	put_ahnd(ahnd);
+
+	gem_quiescent_gpu(spin_fd);
+}
+
+static void log_busy(unsigned int num_engines, uint64_t *val)
+{
+	char buf[1024];
+	int rem = sizeof(buf);
+	unsigned int i;
+	char *p = buf;
+
+	for (i = 0; i < num_engines; i++) {
+		int len;
+
+		len = snprintf(p, rem, "%u=%" PRIu64 "\n",  i, val[i]);
+		igt_assert(len > 0);
+		rem -= len;
+		p += len;
+	}
+
+	igt_info("%s", buf);
+}
+
+static void read_busy_all(int i915, uint64_t *val)
+{
+	struct drm_client_fdinfo info = { };
+
+	igt_assert(igt_parse_drm_fdinfo(i915, &info));
+
+	memcpy(val, info.busy, sizeof(info.busy));
+}
+
+static void
+busy_check_all(int gem_fd, const intel_ctx_t *ctx,
+	       const struct intel_execution_engine2 *e,
+	       const unsigned int num_engines,
+	       const unsigned int classes[16], const unsigned int num_classes,
+	       unsigned int flags)
+{
+	uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+	uint64_t tval[2][16];
+	unsigned long slept;
+	uint64_t val[16];
+	igt_spin_t *spin;
+	unsigned int i;
+
+	memset(tval, 0, sizeof(tval));
+
+	spin = spin_sync(gem_fd, ahnd, ctx, e);
+
+	read_busy_all(gem_fd, tval[0]);
+	slept = measured_usleep(batch_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(gem_fd, spin, flags);
+	read_busy_all(gem_fd, tval[1]);
+
+	end_spin(gem_fd, spin, FLAG_SYNC);
+	igt_spin_free(gem_fd, spin);
+	put_ahnd(ahnd);
+
+	for (i = 0; i < num_classes; i++)
+		val[i] = tval[1][i] - tval[0][i];
+
+	log_busy(num_classes, val);
+
+	for (i = 0; i < num_classes; i++) {
+		double target = i == e->class ? slept : 0.0f;
+
+		assert_within_epsilon(val[i], target, tolerance);
+	}
+
+	gem_quiescent_gpu(gem_fd);
+}
+
+static void
+__submit_spin(int gem_fd, igt_spin_t *spin,
+	      const struct intel_execution_engine2 *e,
+	      int offset)
+{
+	struct drm_i915_gem_execbuffer2 eb = spin->execbuf;
+
+	eb.flags &= ~(0x3f | I915_EXEC_BSD_MASK);
+	eb.flags |= e->flags | I915_EXEC_NO_RELOC;
+	eb.batch_start_offset += offset;
+
+	gem_execbuf(gem_fd, &eb);
+}
+
+static void
+most_busy_check_all(int gem_fd, const intel_ctx_t *ctx,
+		    const struct intel_execution_engine2 *e,
+		    const unsigned int num_engines,
+		    const unsigned int classes[16],
+		    const unsigned int num_classes,
+		    unsigned int flags)
+{
+	uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+	unsigned int busy_class[num_classes];
+	struct intel_execution_engine2 *e_;
+	igt_spin_t *spin = NULL;
+	uint64_t tval[2][16];
+	unsigned long slept;
+	uint64_t val[16];
+	unsigned int i;
+
+	memset(busy_class, 0, sizeof(busy_class));
+	memset(tval, 0, sizeof(tval));
+
+	for_each_ctx_engine(gem_fd, ctx, e_) {
+		if (e->class == e_->class && e->instance == e_->instance) {
+			continue;
+		} else if (spin) {
+			__submit_spin(gem_fd, spin, e_, 64);
+			busy_class[e_->class]++;
+		} else {
+			spin = __spin_poll(gem_fd, ahnd, ctx, e_);
+			busy_class[e_->class]++;
+		}
+	}
+	igt_require(spin); /* at least one busy engine */
+
+	/* Small delay to allow engines to start. */
+	usleep(__spin_wait(gem_fd, spin) * num_engines / 1e3);
+
+	read_busy_all(gem_fd, tval[0]);
+	slept = measured_usleep(batch_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(gem_fd, spin, flags);
+	read_busy_all(gem_fd, tval[1]);
+
+	end_spin(gem_fd, spin, FLAG_SYNC);
+	igt_spin_free(gem_fd, spin);
+	put_ahnd(ahnd);
+
+	for (i = 0; i < num_classes; i++)
+		val[i] = tval[1][i] - tval[0][i];
+
+	log_busy(num_classes, val);
+
+	for (i = 0; i < num_classes; i++) {
+		double target = slept * busy_class[i];
+
+		assert_within_epsilon(val[i], target, tolerance);
+	}
+	gem_quiescent_gpu(gem_fd);
+}
+
+static void
+all_busy_check_all(int gem_fd, const intel_ctx_t *ctx,
+		   const unsigned int num_engines,
+		   const unsigned int classes[16],
+		   const unsigned int num_classes,
+		   unsigned int flags)
+{
+	uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+	unsigned int busy_class[num_classes];
+	struct intel_execution_engine2 *e;
+	igt_spin_t *spin = NULL;
+	uint64_t tval[2][16];
+	unsigned long slept;
+	uint64_t val[16];
+	unsigned int i;
+
+	memset(busy_class, 0, sizeof(busy_class));
+	memset(tval, 0, sizeof(tval));
+
+	for_each_ctx_engine(gem_fd, ctx, e) {
+		if (spin)
+			__submit_spin(gem_fd, spin, e, 64);
+		else
+			spin = __spin_poll(gem_fd, ahnd, ctx, e);
+		busy_class[e->class]++;
+	}
+
+	/* Small delay to allow engines to start. */
+	usleep(__spin_wait(gem_fd, spin) * num_engines / 1e3);
+
+	read_busy_all(gem_fd, tval[0]);
+	slept = measured_usleep(batch_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(gem_fd, spin, flags);
+	read_busy_all(gem_fd, tval[1]);
+
+	end_spin(gem_fd, spin, FLAG_SYNC);
+	igt_spin_free(gem_fd, spin);
+	put_ahnd(ahnd);
+
+	for (i = 0; i < num_classes; i++)
+		val[i] = tval[1][i] - tval[0][i];
+
+	log_busy(num_classes, val);
+
+	for (i = 0; i < num_classes; i++) {
+		double target = slept * busy_class[i];
+
+		assert_within_epsilon(val[i], target, tolerance);
+	}
+	gem_quiescent_gpu(gem_fd);
+}
+
+#define test_each_engine(T, i915, ctx, e) \
+	igt_subtest_with_dynamic(T) for_each_ctx_engine(i915, ctx, e) \
+		igt_dynamic_f("%s", e->name)
+
+igt_main
+{
+	unsigned int num_engines = 0, num_classes = 0;
+	const struct intel_execution_engine2 *e;
+	unsigned int classes[16] = { };
+	const intel_ctx_t *ctx = NULL;
+	int i915 = -1;
+
+	igt_fixture {
+		unsigned int i;
+
+		i915 = __drm_open_driver(DRIVER_INTEL);
+
+		igt_require_gem(i915);
+
+		ctx = intel_ctx_create_all_physical(i915);
+
+		for_each_ctx_engine(i915, ctx, e) {
+			num_engines++;
+			igt_assert(e->class < ARRAY_SIZE(classes));
+			classes[e->class]++;
+		}
+		igt_require(num_engines);
+
+		for (i = 0; i < ARRAY_SIZE(classes); i++) {
+			if (classes[i])
+				num_classes++;
+		}
+		igt_assert(num_classes);
+	}
+
+	/**
+	 * Test basic fdinfo content.
+	 */
+	igt_subtest("basics")
+		basics(i915, num_classes);
+
+	/**
+	 * Test that engines show no load when idle.
+	 */
+	test_each_engine("idle", i915, ctx, e)
+		single(i915, ctx, e, 0);
+
+	/**
+	 * Test that a single engine reports load correctly.
+	 */
+	test_each_engine("busy", i915, ctx, e)
+		single(i915, ctx, e, TEST_BUSY);
+
+	test_each_engine("busy-idle", i915, ctx, e)
+		single(i915, ctx, e, TEST_BUSY | TEST_TRAILING_IDLE);
+
+	test_each_engine("busy-hang", i915, ctx, e) {
+		igt_hang_t hang = igt_allow_hang(i915, ctx->id, 0);
+
+		single(i915, ctx, e, TEST_BUSY | FLAG_HANG);
+
+		igt_disallow_hang(i915, hang);
+	}
+
+	/**
+	 * Test that when one engine is loaded other report no
+	 * load.
+	 */
+	test_each_engine("busy-check-all", i915, ctx, e)
+		busy_check_all(i915, ctx, e, num_engines, classes, num_classes,
+			       TEST_BUSY);
+
+	test_each_engine("busy-idle-check-all", i915, ctx, e)
+		busy_check_all(i915, ctx, e, num_engines, classes, num_classes,
+			       TEST_BUSY | TEST_TRAILING_IDLE);
+
+	/**
+	 * Test that when all except one engine are loaded all
+	 * loads are correctly reported.
+	 */
+	test_each_engine("most-busy-check-all", i915, ctx, e)
+		most_busy_check_all(i915, ctx, e, num_engines,
+				    classes, num_classes,
+				    TEST_BUSY);
+
+	test_each_engine("most-busy-idle-check-all", i915, ctx, e)
+		most_busy_check_all(i915, ctx, e, num_engines,
+				    classes, num_classes,
+				    TEST_BUSY | TEST_TRAILING_IDLE);
+
+	/**
+	 * Test that when all engines are loaded all loads are
+	 * correctly reported.
+	 */
+	igt_subtest("all-busy-check-all")
+		all_busy_check_all(i915, ctx, num_engines, classes, num_classes,
+				   TEST_BUSY);
+
+	igt_subtest("all-busy-idle-check-all")
+		all_busy_check_all(i915, ctx, num_engines, classes, num_classes,
+				   TEST_BUSY | TEST_TRAILING_IDLE);
+
+	/**
+	 * Test for no cross-client contamination.
+	 */
+	test_each_engine("isolation", i915, ctx, e)
+		single(i915, ctx, e, TEST_BUSY | TEST_ISOLATION);
+
+	igt_fixture {
+		intel_ctx_destroy(i915, ctx);
+		close(i915);
+	}
+}
tests/meson.build +8 -0
index 7003d0641d1d..0a87755d5433 100644
@@ -290,6 +290,14 @@ foreach prog : i915_progs
 	test_list += prog
 endforeach
 
+test_executables += executable('drm_fdinfo',
+	   join_paths('i915', 'drm_fdinfo.c'),
+	   dependencies : test_deps + [ lib_igt_drm_fdinfo ],
+	   install_dir : libexecdir,
+	   install_rpath : libexecdir_rpathdir,
+	   install : true)
+test_list += 'drm_fdinfo'
+
 test_executables += executable('dumb_buffer', 'dumb_buffer.c',
 	   dependencies : test_deps + [ libatomic ],
 	   install_dir : libexecdir,
Signature · 1 line
2.32.0
Reviewed-by on v1 2/11
#5 lore raw

Re: [igt-dev] [PATCH i-g-t 02/11] tests/i915/drm_fdinfo: Basic and functional tests for GPU busyness exported via fdinfo

This looks very similar to existing perf_pmu tests with the slight change that the busyness is now captured from the fdinfo.

lgtm,

Umesh

Quoted 595 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Mostly inherited from the perf_pmu, some basic tests, and some tests to verify exported GPU busyness is as expected.

---
tests/i915/drm_fdinfo.c | 555 ++++++++++++++++++++++++++++++++++++++++
tests/meson.build | 8 +

2 files changed, 563 insertions(+)

create mode 100644 tests/i915/drm_fdinfo.c

tests/i915/drm_fdinfo.c new file +555 -0
new file mode 100644
index 000000000000..e3b1ebb0f454
@@ -0,0 +1,555 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ *
+ */
+
+#include "igt.h"
+#include "igt_core.h"
+#include "igt_device.h"
+#include "igt_drm_fdinfo.h"
+#include "i915/gem.h"
+#include "intel_ctx.h"
+
+IGT_TEST_DESCRIPTION("Test the i915 drm fdinfo data");
+
+const double tolerance = 0.05f;
+const unsigned long batch_duration_ns = 500e6;
+
+#define __assert_within_epsilon(x, ref, tol_up, tol_down) \
+	igt_assert_f((double)(x) <= (1.0 + (tol_up)) * (double)(ref) && \
+		     (double)(x) >= (1.0 - (tol_down)) * (double)(ref), \
+		     "'%s' != '%s' (%f not within +%.1f%%/-%.1f%% tolerance of %f)\n",\
+		     #x, #ref, (double)(x), \
+		     (tol_up) * 100.0, (tol_down) * 100.0, \
+		     (double)(ref))
+
+#define assert_within_epsilon(x, ref, tolerance) \
+	__assert_within_epsilon(x, ref, tolerance, tolerance)
+
+static void basics(int i915, unsigned int num_classes)
+{
+	struct drm_client_fdinfo info = { };
+	bool ret;
+
+	ret = igt_parse_drm_fdinfo(i915, &info);
+	igt_assert(ret);
+
+	igt_assert(!strcmp(info.driver, "i915"));
+
+	igt_assert_eq(info.num_engines, num_classes);
+}
+
+/*
+ * Helper for cases where we assert on time spent sleeping (directly or
+ * indirectly), so make it more robust by ensuring the system sleep time
+ * is within test tolerance to start with.
+ */
+static unsigned int measured_usleep(unsigned int usec)
+{
+	struct timespec ts = { };
+	unsigned int slept;
+
+	slept = igt_nsec_elapsed(&ts);
+	igt_assert(slept == 0);
+	do {
+		usleep(usec - slept);
+		slept = igt_nsec_elapsed(&ts) / 1000;
+	} while (slept < usec);
+
+	return igt_nsec_elapsed(&ts);
+}
+
+#define TEST_BUSY (1)
+#define FLAG_SYNC (2)
+#define TEST_TRAILING_IDLE (4)
+#define FLAG_HANG (8)
+#define TEST_ISOLATION (16)
+
+static igt_spin_t *__spin_poll(int fd, uint64_t ahnd, const intel_ctx_t *ctx,
+			       const struct intel_execution_engine2 *e)
+{
+	struct igt_spin_factory opts = {
+		.ahnd = ahnd,
+		.ctx = ctx,
+		.engine = e->flags,
+	};
+
+	if (gem_class_can_store_dword(fd, e->class))
+		opts.flags |= IGT_SPIN_POLL_RUN;
+
+	return __igt_spin_factory(fd, &opts);
+}
+
+static unsigned long __spin_wait(int fd, igt_spin_t *spin)
+{
+	struct timespec start = { };
+
+	igt_nsec_elapsed(&start);
+
+	if (igt_spin_has_poll(spin)) {
+		unsigned long timeout = 0;
+
+		while (!igt_spin_has_started(spin)) {
+			unsigned long t = igt_nsec_elapsed(&start);
+
+			igt_assert(gem_bo_busy(fd, spin->handle));
+			if ((t - timeout) > 250e6) {
+				timeout = t;
+				igt_warn("Spinner not running after %.2fms\n",
+					 (double)t / 1e6);
+				igt_assert(t < 2e9);
+			}
+		}
+	} else {
+		igt_debug("__spin_wait - usleep mode\n");
+		usleep(500e3); /* Better than nothing! */
+	}
+
+	igt_assert(gem_bo_busy(fd, spin->handle));
+	return igt_nsec_elapsed(&start);
+}
+
+static igt_spin_t *__spin_sync(int fd, uint64_t ahnd, const intel_ctx_t *ctx,
+			       const struct intel_execution_engine2 *e)
+{
+	igt_spin_t *spin = __spin_poll(fd, ahnd, ctx, e);
+
+	__spin_wait(fd, spin);
+
+	return spin;
+}
+
+static igt_spin_t *spin_sync(int fd, uint64_t ahnd, const intel_ctx_t *ctx,
+			     const struct intel_execution_engine2 *e)
+{
+	igt_require_gem(fd);
+
+	return __spin_sync(fd, ahnd, ctx, e);
+}
+
+static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
+{
+	if (!spin)
+		return;
+
+	igt_spin_end(spin);
+
+	if (flags & FLAG_SYNC)
+		gem_sync(fd, spin->handle);
+
+	if (flags & TEST_TRAILING_IDLE) {
+		unsigned long t, timeout = 0;
+		struct timespec start = { };
+
+		igt_nsec_elapsed(&start);
+
+		do {
+			t = igt_nsec_elapsed(&start);
+
+			if (gem_bo_busy(fd, spin->handle) &&
+			    (t - timeout) > 10e6) {
+				timeout = t;
+				igt_warn("Spinner not idle after %.2fms\n",
+					 (double)t / 1e6);
+			}
+
+			usleep(1e3);
+		} while (t < batch_duration_ns / 5);
+	}
+}
+
+static uint64_t read_busy(int i915, unsigned int class)
+{
+	struct drm_client_fdinfo info = { };
+
+	igt_assert(igt_parse_drm_fdinfo(i915, &info));
+
+	return info.busy[class];
+}
+
+static void
+single(int gem_fd, const intel_ctx_t *ctx,
+       const struct intel_execution_engine2 *e, unsigned int flags)
+{
+	unsigned long slept;
+	igt_spin_t *spin;
+	uint64_t val;
+	int spin_fd;
+	uint64_t ahnd;
+
+	if (flags & TEST_ISOLATION) {
+		spin_fd = gem_reopen_driver(gem_fd);
+		ctx = intel_ctx_create_all_physical(spin_fd);
+	} else {
+		spin_fd = gem_fd;
+	}
+
+	ahnd = get_reloc_ahnd(spin_fd, ctx->id);
+
+	if (flags & TEST_BUSY)
+		spin = spin_sync(spin_fd, ahnd, ctx, e);
+	else
+		spin = NULL;
+
+	val = read_busy(gem_fd, e->class);
+	slept = measured_usleep(batch_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(spin_fd, spin, flags);
+	val = read_busy(gem_fd, e->class) - val;
+
+	if (flags & FLAG_HANG)
+		igt_force_gpu_reset(spin_fd);
+	else
+		end_spin(spin_fd, spin, FLAG_SYNC);
+
+	assert_within_epsilon(val,
+			      (flags & TEST_BUSY) && !(flags & TEST_ISOLATION) ?
+			      slept : 0.0f,
+			      tolerance);
+
+	/* Check for idle after hang. */
+	if (flags & FLAG_HANG) {
+		gem_quiescent_gpu(spin_fd);
+		igt_assert(!gem_bo_busy(spin_fd, spin->handle));
+
+		val = read_busy(gem_fd, e->class);
+		slept = measured_usleep(batch_duration_ns / 1000);
+		val = read_busy(gem_fd, e->class) - val;
+
+		assert_within_epsilon(val, 0, tolerance);
+	}
+
+	igt_spin_free(spin_fd, spin);
+	put_ahnd(ahnd);
+
+	gem_quiescent_gpu(spin_fd);
+}
+
+static void log_busy(unsigned int num_engines, uint64_t *val)
+{
+	char buf[1024];
+	int rem = sizeof(buf);
+	unsigned int i;
+	char *p = buf;
+
+	for (i = 0; i < num_engines; i++) {
+		int len;
+
+		len = snprintf(p, rem, "%u=%" PRIu64 "\n",  i, val[i]);
+		igt_assert(len > 0);
+		rem -= len;
+		p += len;
+	}
+
+	igt_info("%s", buf);
+}
+
+static void read_busy_all(int i915, uint64_t *val)
+{
+	struct drm_client_fdinfo info = { };
+
+	igt_assert(igt_parse_drm_fdinfo(i915, &info));
+
+	memcpy(val, info.busy, sizeof(info.busy));
+}
+
+static void
+busy_check_all(int gem_fd, const intel_ctx_t *ctx,
+	       const struct intel_execution_engine2 *e,
+	       const unsigned int num_engines,
+	       const unsigned int classes[16], const unsigned int num_classes,
+	       unsigned int flags)
+{
+	uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+	uint64_t tval[2][16];
+	unsigned long slept;
+	uint64_t val[16];
+	igt_spin_t *spin;
+	unsigned int i;
+
+	memset(tval, 0, sizeof(tval));
+
+	spin = spin_sync(gem_fd, ahnd, ctx, e);
+
+	read_busy_all(gem_fd, tval[0]);
+	slept = measured_usleep(batch_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(gem_fd, spin, flags);
+	read_busy_all(gem_fd, tval[1]);
+
+	end_spin(gem_fd, spin, FLAG_SYNC);
+	igt_spin_free(gem_fd, spin);
+	put_ahnd(ahnd);
+
+	for (i = 0; i < num_classes; i++)
+		val[i] = tval[1][i] - tval[0][i];
+
+	log_busy(num_classes, val);
+
+	for (i = 0; i < num_classes; i++) {
+		double target = i == e->class ? slept : 0.0f;
+
+		assert_within_epsilon(val[i], target, tolerance);
+	}
+
+	gem_quiescent_gpu(gem_fd);
+}
+
+static void
+__submit_spin(int gem_fd, igt_spin_t *spin,
+	      const struct intel_execution_engine2 *e,
+	      int offset)
+{
+	struct drm_i915_gem_execbuffer2 eb = spin->execbuf;
+
+	eb.flags &= ~(0x3f | I915_EXEC_BSD_MASK);
+	eb.flags |= e->flags | I915_EXEC_NO_RELOC;
+	eb.batch_start_offset += offset;
+
+	gem_execbuf(gem_fd, &eb);
+}
+
+static void
+most_busy_check_all(int gem_fd, const intel_ctx_t *ctx,
+		    const struct intel_execution_engine2 *e,
+		    const unsigned int num_engines,
+		    const unsigned int classes[16],
+		    const unsigned int num_classes,
+		    unsigned int flags)
+{
+	uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+	unsigned int busy_class[num_classes];
+	struct intel_execution_engine2 *e_;
+	igt_spin_t *spin = NULL;
+	uint64_t tval[2][16];
+	unsigned long slept;
+	uint64_t val[16];
+	unsigned int i;
+
+	memset(busy_class, 0, sizeof(busy_class));
+	memset(tval, 0, sizeof(tval));
+
+	for_each_ctx_engine(gem_fd, ctx, e_) {
+		if (e->class == e_->class && e->instance == e_->instance) {
+			continue;
+		} else if (spin) {
+			__submit_spin(gem_fd, spin, e_, 64);
+			busy_class[e_->class]++;
+		} else {
+			spin = __spin_poll(gem_fd, ahnd, ctx, e_);
+			busy_class[e_->class]++;
+		}
+	}
+	igt_require(spin); /* at least one busy engine */
+
+	/* Small delay to allow engines to start. */
+	usleep(__spin_wait(gem_fd, spin) * num_engines / 1e3);
+
+	read_busy_all(gem_fd, tval[0]);
+	slept = measured_usleep(batch_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(gem_fd, spin, flags);
+	read_busy_all(gem_fd, tval[1]);
+
+	end_spin(gem_fd, spin, FLAG_SYNC);
+	igt_spin_free(gem_fd, spin);
+	put_ahnd(ahnd);
+
+	for (i = 0; i < num_classes; i++)
+		val[i] = tval[1][i] - tval[0][i];
+
+	log_busy(num_classes, val);
+
+	for (i = 0; i < num_classes; i++) {
+		double target = slept * busy_class[i];
+
+		assert_within_epsilon(val[i], target, tolerance);
+	}
+	gem_quiescent_gpu(gem_fd);
+}
+
+static void
+all_busy_check_all(int gem_fd, const intel_ctx_t *ctx,
+		   const unsigned int num_engines,
+		   const unsigned int classes[16],
+		   const unsigned int num_classes,
+		   unsigned int flags)
+{
+	uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+	unsigned int busy_class[num_classes];
+	struct intel_execution_engine2 *e;
+	igt_spin_t *spin = NULL;
+	uint64_t tval[2][16];
+	unsigned long slept;
+	uint64_t val[16];
+	unsigned int i;
+
+	memset(busy_class, 0, sizeof(busy_class));
+	memset(tval, 0, sizeof(tval));
+
+	for_each_ctx_engine(gem_fd, ctx, e) {
+		if (spin)
+			__submit_spin(gem_fd, spin, e, 64);
+		else
+			spin = __spin_poll(gem_fd, ahnd, ctx, e);
+		busy_class[e->class]++;
+	}
+
+	/* Small delay to allow engines to start. */
+	usleep(__spin_wait(gem_fd, spin) * num_engines / 1e3);
+
+	read_busy_all(gem_fd, tval[0]);
+	slept = measured_usleep(batch_duration_ns / 1000);
+	if (flags & TEST_TRAILING_IDLE)
+		end_spin(gem_fd, spin, flags);
+	read_busy_all(gem_fd, tval[1]);
+
+	end_spin(gem_fd, spin, FLAG_SYNC);
+	igt_spin_free(gem_fd, spin);
+	put_ahnd(ahnd);
+
+	for (i = 0; i < num_classes; i++)
+		val[i] = tval[1][i] - tval[0][i];
+
+	log_busy(num_classes, val);
+
+	for (i = 0; i < num_classes; i++) {
+		double target = slept * busy_class[i];
+
+		assert_within_epsilon(val[i], target, tolerance);
+	}
+	gem_quiescent_gpu(gem_fd);
+}
+
+#define test_each_engine(T, i915, ctx, e) \
+	igt_subtest_with_dynamic(T) for_each_ctx_engine(i915, ctx, e) \
+		igt_dynamic_f("%s", e->name)
+
+igt_main
+{
+	unsigned int num_engines = 0, num_classes = 0;
+	const struct intel_execution_engine2 *e;
+	unsigned int classes[16] = { };
+	const intel_ctx_t *ctx = NULL;
+	int i915 = -1;
+
+	igt_fixture {
+		unsigned int i;
+
+		i915 = __drm_open_driver(DRIVER_INTEL);
+
+		igt_require_gem(i915);
+
+		ctx = intel_ctx_create_all_physical(i915);
+
+		for_each_ctx_engine(i915, ctx, e) {
+			num_engines++;
+			igt_assert(e->class < ARRAY_SIZE(classes));
+			classes[e->class]++;
+		}
+		igt_require(num_engines);
+
+		for (i = 0; i < ARRAY_SIZE(classes); i++) {
+			if (classes[i])
+				num_classes++;
+		}
+		igt_assert(num_classes);
+	}
+
+	/**
+	 * Test basic fdinfo content.
+	 */
+	igt_subtest("basics")
+		basics(i915, num_classes);
+
+	/**
+	 * Test that engines show no load when idle.
+	 */
+	test_each_engine("idle", i915, ctx, e)
+		single(i915, ctx, e, 0);
+
+	/**
+	 * Test that a single engine reports load correctly.
+	 */
+	test_each_engine("busy", i915, ctx, e)
+		single(i915, ctx, e, TEST_BUSY);
+
+	test_each_engine("busy-idle", i915, ctx, e)
+		single(i915, ctx, e, TEST_BUSY | TEST_TRAILING_IDLE);
+
+	test_each_engine("busy-hang", i915, ctx, e) {
+		igt_hang_t hang = igt_allow_hang(i915, ctx->id, 0);
+
+		single(i915, ctx, e, TEST_BUSY | FLAG_HANG);
+
+		igt_disallow_hang(i915, hang);
+	}
+
+	/**
+	 * Test that when one engine is loaded other report no
+	 * load.
+	 */
+	test_each_engine("busy-check-all", i915, ctx, e)
+		busy_check_all(i915, ctx, e, num_engines, classes, num_classes,
+			       TEST_BUSY);
+
+	test_each_engine("busy-idle-check-all", i915, ctx, e)
+		busy_check_all(i915, ctx, e, num_engines, classes, num_classes,
+			       TEST_BUSY | TEST_TRAILING_IDLE);
+
+	/**
+	 * Test that when all except one engine are loaded all
+	 * loads are correctly reported.
+	 */
+	test_each_engine("most-busy-check-all", i915, ctx, e)
+		most_busy_check_all(i915, ctx, e, num_engines,
+				    classes, num_classes,
+				    TEST_BUSY);
+
+	test_each_engine("most-busy-idle-check-all", i915, ctx, e)
+		most_busy_check_all(i915, ctx, e, num_engines,
+				    classes, num_classes,
+				    TEST_BUSY | TEST_TRAILING_IDLE);
+
+	/**
+	 * Test that when all engines are loaded all loads are
+	 * correctly reported.
+	 */
+	igt_subtest("all-busy-check-all")
+		all_busy_check_all(i915, ctx, num_engines, classes, num_classes,
+				   TEST_BUSY);
+
+	igt_subtest("all-busy-idle-check-all")
+		all_busy_check_all(i915, ctx, num_engines, classes, num_classes,
+				   TEST_BUSY | TEST_TRAILING_IDLE);
+
+	/**
+	 * Test for no cross-client contamination.
+	 */
+	test_each_engine("isolation", i915, ctx, e)
+		single(i915, ctx, e, TEST_BUSY | TEST_ISOLATION);
+
+	igt_fixture {
+		intel_ctx_destroy(i915, ctx);
+		close(i915);
+	}
+}
tests/meson.build +0 -0
index 7003d0641d1d..0a87755d5433 100644
@@ -290,6 +290,14 @@ foreach prog : i915_progs
 	test_list += prog

endforeach

tests/meson.build +8 -0
+test_executables += executable('drm_fdinfo',
+	   join_paths('i915', 'drm_fdinfo.c'),
+	   dependencies : test_deps + [ lib_igt_drm_fdinfo ],
+	   install_dir : libexecdir,
+	   install_rpath : libexecdir_rpathdir,
+	   install : true)
+test_list += 'drm_fdinfo'
+

test_executables += executable('dumb_buffer', 'dumb_buffer.c',
dependencies : test_deps + [ libatomic ], install_dir : libexecdir,

Signature · 1 line
2.32.0
#6 lore raw

Re: [igt-dev] [PATCH i-g-t 02/11] tests/i915/drm_fdinfo: Basic and functional tests for GPU busyness exported via fdinfo

Quoted 1 line · Umesh Nerlige Ramappa

This looks very similar to existing perf_pmu tests with the slight change that the busyness is now captured from the fdinfo.

Yep, much copy-and-paste was involved. :)

Quoted 2 lines

lgtm,

Thanks!

Regards,

Tvrtko

Quoted 616 lines

Umesh

Quoted 612 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Mostly inherited from the perf_pmu, some basic tests, and some tests to verify exported GPU busyness is as expected.

---
tests/i915/drm_fdinfo.c | 555 ++++++++++++++++++++++++++++++++++++++++ tests/meson.build       |   8 +

2 files changed, 563 insertions(+)

create mode 100644 tests/i915/drm_fdinfo.c

tests/i915/drm_fdinfo.c new file +4 -0
new file mode 100644
index 000000000000..e3b1ebb0f454
@@ -0,0 +1,555 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person 

obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ *
+ */

tests/i915/drm_fdinfo.c new file +17 -0
+
+#include "igt.h"
+#include "igt_core.h"
+#include "igt_device.h"
+#include "igt_drm_fdinfo.h"
+#include "i915/gem.h"
+#include "intel_ctx.h"
+
+IGT_TEST_DESCRIPTION("Test the i915 drm fdinfo data");
+
+const double tolerance = 0.05f;
+const unsigned long batch_duration_ns = 500e6;
+
+#define __assert_within_epsilon(x, ref, tol_up, tol_down) \
+    igt_assert_f((double)(x) <= (1.0 + (tol_up)) * (double)(ref) && \
+             (double)(x) >= (1.0 - (tol_down)) * (double)(ref), \
+             "'%s' != '%s' (%f not within +%.1f%%/-%.1f%% tolerance 

of %f)\n",\
+             #x, #ref, (double)(x), \
+             (tol_up) * 100.0, (tol_down) * 100.0, \
+             (double)(ref))

tests/i915/drm_fdinfo.c new file +44 -0
+
+#define assert_within_epsilon(x, ref, tolerance) \
+    __assert_within_epsilon(x, ref, tolerance, tolerance)
+
+static void basics(int i915, unsigned int num_classes)
+{
+    struct drm_client_fdinfo info = { };
+    bool ret;
+
+    ret = igt_parse_drm_fdinfo(i915, &info);
+    igt_assert(ret);
+
+    igt_assert(!strcmp(info.driver, "i915"));
+
+    igt_assert_eq(info.num_engines, num_classes);
+}
+
+/*
+ * Helper for cases where we assert on time spent sleeping (directly or
+ * indirectly), so make it more robust by ensuring the system sleep time
+ * is within test tolerance to start with.
+ */
+static unsigned int measured_usleep(unsigned int usec)
+{
+    struct timespec ts = { };
+    unsigned int slept;
+
+    slept = igt_nsec_elapsed(&ts);
+    igt_assert(slept == 0);
+    do {
+        usleep(usec - slept);
+        slept = igt_nsec_elapsed(&ts) / 1000;
+    } while (slept < usec);
+
+    return igt_nsec_elapsed(&ts);
+}
+
+#define TEST_BUSY (1)
+#define FLAG_SYNC (2)
+#define TEST_TRAILING_IDLE (4)
+#define FLAG_HANG (8)
+#define TEST_ISOLATION (16)
+
+static igt_spin_t *__spin_poll(int fd, uint64_t ahnd, const 

intel_ctx_t *ctx,
+                   const struct intel_execution_engine2 *e)

tests/i915/drm_fdinfo.c new file +43 -0
+{
+    struct igt_spin_factory opts = {
+        .ahnd = ahnd,
+        .ctx = ctx,
+        .engine = e->flags,
+    };
+
+    if (gem_class_can_store_dword(fd, e->class))
+        opts.flags |= IGT_SPIN_POLL_RUN;
+
+    return __igt_spin_factory(fd, &opts);
+}
+
+static unsigned long __spin_wait(int fd, igt_spin_t *spin)
+{
+    struct timespec start = { };
+
+    igt_nsec_elapsed(&start);
+
+    if (igt_spin_has_poll(spin)) {
+        unsigned long timeout = 0;
+
+        while (!igt_spin_has_started(spin)) {
+            unsigned long t = igt_nsec_elapsed(&start);
+
+            igt_assert(gem_bo_busy(fd, spin->handle));
+            if ((t - timeout) > 250e6) {
+                timeout = t;
+                igt_warn("Spinner not running after %.2fms\n",
+                     (double)t / 1e6);
+                igt_assert(t < 2e9);
+            }
+        }
+    } else {
+        igt_debug("__spin_wait - usleep mode\n");
+        usleep(500e3); /* Better than nothing! */
+    }
+
+    igt_assert(gem_bo_busy(fd, spin->handle));
+    return igt_nsec_elapsed(&start);
+}
+
+static igt_spin_t *__spin_sync(int fd, uint64_t ahnd, const 

intel_ctx_t *ctx,
+                   const struct intel_execution_engine2 *e)

tests/i915/drm_fdinfo.c new file +9 -0
+{
+    igt_spin_t *spin = __spin_poll(fd, ahnd, ctx, e);
+
+    __spin_wait(fd, spin);
+
+    return spin;
+}
+
+static igt_spin_t *spin_sync(int fd, uint64_t ahnd, const intel_ctx_t 

*ctx,
+                 const struct intel_execution_engine2 *e)

tests/i915/drm_fdinfo.c new file +137 -0
+{
+    igt_require_gem(fd);
+
+    return __spin_sync(fd, ahnd, ctx, e);
+}
+
+static void end_spin(int fd, igt_spin_t *spin, unsigned int flags)
+{
+    if (!spin)
+        return;
+
+    igt_spin_end(spin);
+
+    if (flags & FLAG_SYNC)
+        gem_sync(fd, spin->handle);
+
+    if (flags & TEST_TRAILING_IDLE) {
+        unsigned long t, timeout = 0;
+        struct timespec start = { };
+
+        igt_nsec_elapsed(&start);
+
+        do {
+            t = igt_nsec_elapsed(&start);
+
+            if (gem_bo_busy(fd, spin->handle) &&
+                (t - timeout) > 10e6) {
+                timeout = t;
+                igt_warn("Spinner not idle after %.2fms\n",
+                     (double)t / 1e6);
+            }
+
+            usleep(1e3);
+        } while (t < batch_duration_ns / 5);
+    }
+}
+
+static uint64_t read_busy(int i915, unsigned int class)
+{
+    struct drm_client_fdinfo info = { };
+
+    igt_assert(igt_parse_drm_fdinfo(i915, &info));
+
+    return info.busy[class];
+}
+
+static void
+single(int gem_fd, const intel_ctx_t *ctx,
+       const struct intel_execution_engine2 *e, unsigned int flags)
+{
+    unsigned long slept;
+    igt_spin_t *spin;
+    uint64_t val;
+    int spin_fd;
+    uint64_t ahnd;
+
+    if (flags & TEST_ISOLATION) {
+        spin_fd = gem_reopen_driver(gem_fd);
+        ctx = intel_ctx_create_all_physical(spin_fd);
+    } else {
+        spin_fd = gem_fd;
+    }
+
+    ahnd = get_reloc_ahnd(spin_fd, ctx->id);
+
+    if (flags & TEST_BUSY)
+        spin = spin_sync(spin_fd, ahnd, ctx, e);
+    else
+        spin = NULL;
+
+    val = read_busy(gem_fd, e->class);
+    slept = measured_usleep(batch_duration_ns / 1000);
+    if (flags & TEST_TRAILING_IDLE)
+        end_spin(spin_fd, spin, flags);
+    val = read_busy(gem_fd, e->class) - val;
+
+    if (flags & FLAG_HANG)
+        igt_force_gpu_reset(spin_fd);
+    else
+        end_spin(spin_fd, spin, FLAG_SYNC);
+
+    assert_within_epsilon(val,
+                  (flags & TEST_BUSY) && !(flags & TEST_ISOLATION) ?
+                  slept : 0.0f,
+                  tolerance);
+
+    /* Check for idle after hang. */
+    if (flags & FLAG_HANG) {
+        gem_quiescent_gpu(spin_fd);
+        igt_assert(!gem_bo_busy(spin_fd, spin->handle));
+
+        val = read_busy(gem_fd, e->class);
+        slept = measured_usleep(batch_duration_ns / 1000);
+        val = read_busy(gem_fd, e->class) - val;
+
+        assert_within_epsilon(val, 0, tolerance);
+    }
+
+    igt_spin_free(spin_fd, spin);
+    put_ahnd(ahnd);
+
+    gem_quiescent_gpu(spin_fd);
+}
+
+static void log_busy(unsigned int num_engines, uint64_t *val)
+{
+    char buf[1024];
+    int rem = sizeof(buf);
+    unsigned int i;
+    char *p = buf;
+
+    for (i = 0; i < num_engines; i++) {
+        int len;
+
+        len = snprintf(p, rem, "%u=%" PRIu64 "\n",  i, val[i]);
+        igt_assert(len > 0);
+        rem -= len;
+        p += len;
+    }
+
+    igt_info("%s", buf);
+}
+
+static void read_busy_all(int i915, uint64_t *val)
+{
+    struct drm_client_fdinfo info = { };
+
+    igt_assert(igt_parse_drm_fdinfo(i915, &info));
+
+    memcpy(val, info.busy, sizeof(info.busy));
+}
+
+static void
+busy_check_all(int gem_fd, const intel_ctx_t *ctx,
+           const struct intel_execution_engine2 *e,
+           const unsigned int num_engines,
+           const unsigned int classes[16], const unsigned int 

num_classes,
+           unsigned int flags)

tests/i915/drm_fdinfo.c new file +275 -0
+{
+    uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+    uint64_t tval[2][16];
+    unsigned long slept;
+    uint64_t val[16];
+    igt_spin_t *spin;
+    unsigned int i;
+
+    memset(tval, 0, sizeof(tval));
+
+    spin = spin_sync(gem_fd, ahnd, ctx, e);
+
+    read_busy_all(gem_fd, tval[0]);
+    slept = measured_usleep(batch_duration_ns / 1000);
+    if (flags & TEST_TRAILING_IDLE)
+        end_spin(gem_fd, spin, flags);
+    read_busy_all(gem_fd, tval[1]);
+
+    end_spin(gem_fd, spin, FLAG_SYNC);
+    igt_spin_free(gem_fd, spin);
+    put_ahnd(ahnd);
+
+    for (i = 0; i < num_classes; i++)
+        val[i] = tval[1][i] - tval[0][i];
+
+    log_busy(num_classes, val);
+
+    for (i = 0; i < num_classes; i++) {
+        double target = i == e->class ? slept : 0.0f;
+
+        assert_within_epsilon(val[i], target, tolerance);
+    }
+
+    gem_quiescent_gpu(gem_fd);
+}
+
+static void
+__submit_spin(int gem_fd, igt_spin_t *spin,
+          const struct intel_execution_engine2 *e,
+          int offset)
+{
+    struct drm_i915_gem_execbuffer2 eb = spin->execbuf;
+
+    eb.flags &= ~(0x3f | I915_EXEC_BSD_MASK);
+    eb.flags |= e->flags | I915_EXEC_NO_RELOC;
+    eb.batch_start_offset += offset;
+
+    gem_execbuf(gem_fd, &eb);
+}
+
+static void
+most_busy_check_all(int gem_fd, const intel_ctx_t *ctx,
+            const struct intel_execution_engine2 *e,
+            const unsigned int num_engines,
+            const unsigned int classes[16],
+            const unsigned int num_classes,
+            unsigned int flags)
+{
+    uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+    unsigned int busy_class[num_classes];
+    struct intel_execution_engine2 *e_;
+    igt_spin_t *spin = NULL;
+    uint64_t tval[2][16];
+    unsigned long slept;
+    uint64_t val[16];
+    unsigned int i;
+
+    memset(busy_class, 0, sizeof(busy_class));
+    memset(tval, 0, sizeof(tval));
+
+    for_each_ctx_engine(gem_fd, ctx, e_) {
+        if (e->class == e_->class && e->instance == e_->instance) {
+            continue;
+        } else if (spin) {
+            __submit_spin(gem_fd, spin, e_, 64);
+            busy_class[e_->class]++;
+        } else {
+            spin = __spin_poll(gem_fd, ahnd, ctx, e_);
+            busy_class[e_->class]++;
+        }
+    }
+    igt_require(spin); /* at least one busy engine */
+
+    /* Small delay to allow engines to start. */
+    usleep(__spin_wait(gem_fd, spin) * num_engines / 1e3);
+
+    read_busy_all(gem_fd, tval[0]);
+    slept = measured_usleep(batch_duration_ns / 1000);
+    if (flags & TEST_TRAILING_IDLE)
+        end_spin(gem_fd, spin, flags);
+    read_busy_all(gem_fd, tval[1]);
+
+    end_spin(gem_fd, spin, FLAG_SYNC);
+    igt_spin_free(gem_fd, spin);
+    put_ahnd(ahnd);
+
+    for (i = 0; i < num_classes; i++)
+        val[i] = tval[1][i] - tval[0][i];
+
+    log_busy(num_classes, val);
+
+    for (i = 0; i < num_classes; i++) {
+        double target = slept * busy_class[i];
+
+        assert_within_epsilon(val[i], target, tolerance);
+    }
+    gem_quiescent_gpu(gem_fd);
+}
+
+static void
+all_busy_check_all(int gem_fd, const intel_ctx_t *ctx,
+           const unsigned int num_engines,
+           const unsigned int classes[16],
+           const unsigned int num_classes,
+           unsigned int flags)
+{
+    uint64_t ahnd = get_reloc_ahnd(gem_fd, ctx->id);
+    unsigned int busy_class[num_classes];
+    struct intel_execution_engine2 *e;
+    igt_spin_t *spin = NULL;
+    uint64_t tval[2][16];
+    unsigned long slept;
+    uint64_t val[16];
+    unsigned int i;
+
+    memset(busy_class, 0, sizeof(busy_class));
+    memset(tval, 0, sizeof(tval));
+
+    for_each_ctx_engine(gem_fd, ctx, e) {
+        if (spin)
+            __submit_spin(gem_fd, spin, e, 64);
+        else
+            spin = __spin_poll(gem_fd, ahnd, ctx, e);
+        busy_class[e->class]++;
+    }
+
+    /* Small delay to allow engines to start. */
+    usleep(__spin_wait(gem_fd, spin) * num_engines / 1e3);
+
+    read_busy_all(gem_fd, tval[0]);
+    slept = measured_usleep(batch_duration_ns / 1000);
+    if (flags & TEST_TRAILING_IDLE)
+        end_spin(gem_fd, spin, flags);
+    read_busy_all(gem_fd, tval[1]);
+
+    end_spin(gem_fd, spin, FLAG_SYNC);
+    igt_spin_free(gem_fd, spin);
+    put_ahnd(ahnd);
+
+    for (i = 0; i < num_classes; i++)
+        val[i] = tval[1][i] - tval[0][i];
+
+    log_busy(num_classes, val);
+
+    for (i = 0; i < num_classes; i++) {
+        double target = slept * busy_class[i];
+
+        assert_within_epsilon(val[i], target, tolerance);
+    }
+    gem_quiescent_gpu(gem_fd);
+}
+
+#define test_each_engine(T, i915, ctx, e) \
+    igt_subtest_with_dynamic(T) for_each_ctx_engine(i915, ctx, e) \
+        igt_dynamic_f("%s", e->name)
+
+igt_main
+{
+    unsigned int num_engines = 0, num_classes = 0;
+    const struct intel_execution_engine2 *e;
+    unsigned int classes[16] = { };
+    const intel_ctx_t *ctx = NULL;
+    int i915 = -1;
+
+    igt_fixture {
+        unsigned int i;
+
+        i915 = __drm_open_driver(DRIVER_INTEL);
+
+        igt_require_gem(i915);
+
+        ctx = intel_ctx_create_all_physical(i915);
+
+        for_each_ctx_engine(i915, ctx, e) {
+            num_engines++;
+            igt_assert(e->class < ARRAY_SIZE(classes));
+            classes[e->class]++;
+        }
+        igt_require(num_engines);
+
+        for (i = 0; i < ARRAY_SIZE(classes); i++) {
+            if (classes[i])
+                num_classes++;
+        }
+        igt_assert(num_classes);
+    }
+
+    /**
+     * Test basic fdinfo content.
+     */
+    igt_subtest("basics")
+        basics(i915, num_classes);
+
+    /**
+     * Test that engines show no load when idle.
+     */
+    test_each_engine("idle", i915, ctx, e)
+        single(i915, ctx, e, 0);
+
+    /**
+     * Test that a single engine reports load correctly.
+     */
+    test_each_engine("busy", i915, ctx, e)
+        single(i915, ctx, e, TEST_BUSY);
+
+    test_each_engine("busy-idle", i915, ctx, e)
+        single(i915, ctx, e, TEST_BUSY | TEST_TRAILING_IDLE);
+
+    test_each_engine("busy-hang", i915, ctx, e) {
+        igt_hang_t hang = igt_allow_hang(i915, ctx->id, 0);
+
+        single(i915, ctx, e, TEST_BUSY | FLAG_HANG);
+
+        igt_disallow_hang(i915, hang);
+    }
+
+    /**
+     * Test that when one engine is loaded other report no
+     * load.
+     */
+    test_each_engine("busy-check-all", i915, ctx, e)
+        busy_check_all(i915, ctx, e, num_engines, classes, num_classes,
+                   TEST_BUSY);
+
+    test_each_engine("busy-idle-check-all", i915, ctx, e)
+        busy_check_all(i915, ctx, e, num_engines, classes, num_classes,
+                   TEST_BUSY | TEST_TRAILING_IDLE);
+
+    /**
+     * Test that when all except one engine are loaded all
+     * loads are correctly reported.
+     */
+    test_each_engine("most-busy-check-all", i915, ctx, e)
+        most_busy_check_all(i915, ctx, e, num_engines,
+                    classes, num_classes,
+                    TEST_BUSY);
+
+    test_each_engine("most-busy-idle-check-all", i915, ctx, e)
+        most_busy_check_all(i915, ctx, e, num_engines,
+                    classes, num_classes,
+                    TEST_BUSY | TEST_TRAILING_IDLE);
+
+    /**
+     * Test that when all engines are loaded all loads are
+     * correctly reported.
+     */
+    igt_subtest("all-busy-check-all")
+        all_busy_check_all(i915, ctx, num_engines, classes, num_classes,
+                   TEST_BUSY);
+
+    igt_subtest("all-busy-idle-check-all")
+        all_busy_check_all(i915, ctx, num_engines, classes, num_classes,
+                   TEST_BUSY | TEST_TRAILING_IDLE);
+
+    /**
+     * Test for no cross-client contamination.
+     */
+    test_each_engine("isolation", i915, ctx, e)
+        single(i915, ctx, e, TEST_BUSY | TEST_ISOLATION);
+
+    igt_fixture {
+        intel_ctx_destroy(i915, ctx);
+        close(i915);
+    }
+}
tests/meson.build +0 -0
index 7003d0641d1d..0a87755d5433 100644
@@ -290,6 +290,14 @@ foreach prog : i915_progs

    test_list += prog
endforeach

tests/meson.build +8 -0
+test_executables += executable('drm_fdinfo',
+       join_paths('i915', 'drm_fdinfo.c'),
+       dependencies : test_deps + [ lib_igt_drm_fdinfo ],
+       install_dir : libexecdir,
+       install_rpath : libexecdir_rpathdir,
+       install : true)
+test_list += 'drm_fdinfo'
+

test_executables += executable('dumb_buffer', 'dumb_buffer.c', dependencies : test_deps + [ libatomic ], install_dir : libexecdir,

Signature · 1 line
2.32.0
#7 lore raw

PATCH 3/11 intel-gpu-top: Add support for per client stats

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Use the i915 exported data in /proc/<pid>/fdinfo to show GPU utilization per DRM client.

Example of the output:

intel-gpu-top: Intel Tigerlake (Gen12) @ /dev/dri/card0 - 220/ 221 MHz
70% RC6; 0.62/ 7.08 W; 760 irqs/s

ENGINES BUSY MI_SEMA MI_WAIT
Render/3D 23.06% |██████▊ | 0% 0%
Blitter 0.00% | | 0% 0%
Video 5.40% |█▋ | 0% 0%
VideoEnhance 20.67% |██████ | 0% 0%

   PID              NAME  Render/3D    Blitter      Video    VideoEnhance
  3082               mpv |          ||          ||▌         ||██        |
  3117         neverball |█▉        ||          ||          ||          |
     1           systemd |▍         ||          ||          ||          |
  2338       gnome-shell |          ||          ||          ||          |
---
 man/intel_gpu_top.rst |   4 +
 tools/intel_gpu_top.c | 801 +++++++++++++++++++++++++++++++++++++++++-
 tools/meson.build     |   2 +-
 3 files changed, 804 insertions(+), 3 deletions(-)
man/intel_gpu_top.rst +4 -0
index b3b765b05feb..f4dbfc5b44d9 100644
@@ -56,6 +56,10 @@ Supported keys:
     'q'    Exit from the tool.
     'h'    Show interactive help.
     '1'    Toggle between aggregated engine class and physical engine mode.
+    'n'    Toggle display of numeric client busyness overlay.
+    's'    Toggle between sort modes (runtime, total runtime, pid, client id).
+    'i'    Toggle display of clients which used no GPU time.
+    'H'    Toggle between per PID aggregation and individual clients.
 
 DEVICE SELECTION
 ================
tools/intel_gpu_top.c +799 -2

892 lines not on this page · raw message

tools/meson.build +1 -1
index b6b9753463a9..771d0b9e3d5d 100644
@@ -91,7 +91,7 @@ install_subdir('registers', install_dir : datadir)
 executable('intel_gpu_top', 'intel_gpu_top.c',
 	   install : true,
 	   install_rpath : bindir_rpathdir,
-	   dependencies : [lib_igt_perf,lib_igt_device_scan,math])
+	   dependencies : [lib_igt_perf,lib_igt_device_scan,lib_igt_drm_fdinfo,math])
 
 executable('amd_hdmi_compliance', 'amd_hdmi_compliance.c',
 	   dependencies : [tool_deps],
Signature · 1 line
2.32.0
Reviewed-by on v1 3/11
#8 lore raw

Re: [igt-dev] [PATCH i-g-t 03/11] intel-gpu-top: Add support for per client stats

lgtm, I just have a few nits and questions below:

Regardless, this is

Umesh

Quoted 162 lines · Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Use the i915 exported data in /proc/<pid>/fdinfo to show GPU utilization per DRM client.

Example of the output:

intel-gpu-top: Intel Tigerlake (Gen12) @ /dev/dri/card0 - 220/ 221 MHz
70% RC6; 0.62/ 7.08 W; 760 irqs/s

ENGINES BUSY MI_SEMA MI_WAIT
Render/3D 23.06% |██████▊ | 0% 0%
Blitter 0.00% | | 0% 0%
Video 5.40% |█▋ | 0% 0%
VideoEnhance 20.67% |██████ | 0% 0%

PID NAME Render/3D Blitter Video VideoEnhance

 3082               mpv |          ||          ||▌         ||██        |
 3117         neverball |█▉        ||          ||          ||          |
    1           systemd |▍         ||          ||          ||          |
 2338       gnome-shell |          ||          ||          ||          |

---

man/intel_gpu_top.rst |   4 +
tools/intel_gpu_top.c | 801 +++++++++++++++++++++++++++++++++++++++++-
tools/meson.build     |   2 +-
3 files changed, 804 insertions(+), 3 deletions(-)
man/intel_gpu_top.rst +4 -0
index b3b765b05feb..f4dbfc5b44d9 100644
@@ -56,6 +56,10 @@ Supported keys:
    'q'    Exit from the tool.
    'h'    Show interactive help.
    '1'    Toggle between aggregated engine class and physical engine mode.
+    'n'    Toggle display of numeric client busyness overlay.
+    's'    Toggle between sort modes (runtime, total runtime, pid, client id).
+    'i'    Toggle display of clients which used no GPU time.
+    'H'    Toggle between per PID aggregation and individual clients.
 

DEVICE SELECTION
================

tools/intel_gpu_top.c +93 -1
index bc11fce2bb1e..73815cdea8aa 100644
@@ -43,8 +43,10 @@
 #include <sys/types.h>
 #include <unistd.h>
 #include <termios.h>
+#include <sys/sysmacros.h>
 
 #include "igt_perf.h"
+#include "igt_drm_fdinfo.h"
 
 #define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
 
@@ -311,7 +313,8 @@ static int engine_cmp(const void *__a, const void *__b)
 		return a->instance - b->instance;
 }
 
-#define is_igpu_pci(x) (strcmp(x, "0000:00:02.0") == 0)
+#define IGPU_PCI "0000:00:02.0"
+#define is_igpu_pci(x) (strcmp(x, IGPU_PCI) == 0)
 #define is_igpu(x) (strcmp(x, "i915") == 0)
 
 static struct engines *discover_engines(char *device)
@@ -635,6 +638,547 @@ static void pmu_sample(struct engines *engines)
 	}
 }
 
+enum client_status {
+	FREE = 0, /* mbz */
+	ALIVE,
+	PROBE
+};
+
+struct clients;
+
+struct client {
+	struct clients *clients;
+
+	enum client_status status;
+	unsigned int id;
+	unsigned int pid;
+	char name[24];
+	char print_name[24];
+	unsigned int samples;
+	unsigned long total_runtime;
+	unsigned long last_runtime;
+	unsigned long *val;
+	uint64_t *last;
+};
+
+struct clients {
+	unsigned int num_clients;
+	unsigned int active_clients;
+
+	unsigned int num_classes;
+	struct engine_class *class;
+
+	char pci_slot[64];
+
+	struct client *client;
+};
+
+#define for_each_client(clients, c, tmp) \
+	for ((tmp) = (clients)->num_clients, c = (clients)->client; \
+	     (tmp > 0); (tmp)--, (c)++)
+
+static struct clients *init_clients(const char *pci_slot)
+{
+	struct clients *clients;
+
+	clients = malloc(sizeof(*clients));
+	if (!clients)
+		return NULL;
+
+	memset(clients, 0, sizeof(*clients));
+
+	strncpy(clients->pci_slot, pci_slot, sizeof(clients->pci_slot));
+
+	return clients;
+}
+
+static struct client *
+find_client(struct clients *clients, enum client_status status, unsigned int id)
+{
+	unsigned int start, num;
+	struct client *c;
+
+	start = status == FREE ? clients->active_clients : 0; /* Free block at the end. */
+	num = clients->num_clients - start;
+
+	for (c = &clients->client[start]; num; c++, num--) {
+		if (status != c->status)
+			continue;
+
+		if (status == FREE || c->id == id)
+			return c;
+	}
+
+	return NULL;
+}
+
+static void
+update_client(struct client *c, unsigned int pid, char *name, uint64_t val[16])
+{
+	unsigned int i;
+
+	if (c->pid != pid)
+		c->pid = pid;
+
+	if (strcmp(c->name, name)) {
+		char *p;
+
+		strncpy(c->name, name, sizeof(c->name) - 1);
+		strncpy(c->print_name, name, sizeof(c->print_name) - 1);
+
+		p = c->print_name;

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 739

Quoted 10 lines
tools/intel_gpu_top.c +10 -0
+		while (*p) {
+			if (!isprint(*p))
+				*p = '*';
+			p++;
+		}
+	}
+
+	c->last_runtime = 0;
+	c->total_runtime = 0;
+

assert(c->clients->num_classes <= 16);

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 744

Quoted 5 lines
tools/intel_gpu_top.c +5 -0
+	for (i = 0; i < c->clients->num_classes; i++) {
+		if (val[i] < c->last[i])
+			continue; /* It will catch up soon. */
+
+		c->total_runtime += val[i];

As far as busyness is concerned c->total_runtime += val[i] should be it.

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 747

Quoted 3 lines
tools/intel_gpu_top.c +3 -0
+		c->val[i] = val[i] - c->last[i];
+		c->last_runtime += c->val[i];
+		c->last[i] = val[i];

Can you describe what these 3 lines are doing?

Quoted 55 lines
tools/intel_gpu_top.c +55 -0
+	}
+
+	c->samples++;
+	c->status = ALIVE;
+}
+
+static void
+add_client(struct clients *clients, unsigned int id, unsigned int pid,
+	   char *name, uint64_t busy[16])
+{
+	struct client *c;
+
+	assert(!find_client(clients, ALIVE, id));
+
+	c = find_client(clients, FREE, 0);
+	if (!c) {
+		unsigned int idx = clients->num_clients;
+
+		clients->num_clients += (clients->num_clients + 2) / 2;
+		clients->client = realloc(clients->client,
+					  clients->num_clients * sizeof(*c));
+		assert(clients->client);
+
+		c = &clients->client[idx];
+		memset(c, 0, (clients->num_clients - idx) * sizeof(*c));
+	}
+
+	c->id = id;
+	c->clients = clients;
+	c->val = calloc(clients->num_classes, sizeof(c->val));
+	c->last = calloc(clients->num_classes, sizeof(c->last));
+	assert(c->val && c->last);
+
+	update_client(c, pid, name, busy);
+}
+
+static void free_client(struct client *c)
+{
+	free(c->val);
+	free(c->last);
+	memset(c, 0, sizeof(*c));
+}
+
+static int client_last_cmp(const void *_a, const void *_b)
+{
+	const struct client *a = _a;
+	const struct client *b = _b;
+	long tot_a, tot_b;
+
+	/*
+	 * Sort clients in descending order of runtime in the previous sampling
+	 * period for active ones, followed by inactive. Tie-breaker is client
+	 * id.
+	 */
+

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 812

Quoted 10 lines
tools/intel_gpu_top.c +10 -0
+	tot_a = a->status == ALIVE ? a->last_runtime : -1;
+	tot_b = b->status == ALIVE ? b->last_runtime : -1;
+
+	tot_b -= tot_a;
+	if (tot_b > 0)
+		return 1;
+	if (tot_b < 0)
+		return -1;
+
+	return (int)b->id - a->id;

nit: the compare functions could use a single if, if you agree on just returning tot_b.

	if (!tot_b)
		return (int)b->id - a->id;

	return tot_b;
Quoted 118 lines
tools/intel_gpu_top.c +118 -0
+}
+
+static int client_total_cmp(const void *_a, const void *_b)
+{
+	const struct client *a = _a;
+	const struct client *b = _b;
+	long tot_a, tot_b;
+
+	tot_a = a->status == ALIVE ? a->total_runtime : -1;
+	tot_b = b->status == ALIVE ? b->total_runtime : -1;
+
+	tot_b -= tot_a;
+	if (tot_b > 0)
+		return 1;
+	if (tot_b < 0)
+		return -1;
+
+	return (int)b->id - a->id;
+}
+
+static int client_id_cmp(const void *_a, const void *_b)
+{
+	const struct client *a = _a;
+	const struct client *b = _b;
+	int id_a, id_b;
+
+	id_a = a->status == ALIVE ? a->id : -1;
+	id_b = b->status == ALIVE ? b->id : -1;
+
+	id_b -= id_a;
+	if (id_b > 0)
+		return 1;
+	if (id_b < 0)
+		return -1;
+
+	return (int)b->id - a->id;
+}
+
+static int client_pid_cmp(const void *_a, const void *_b)
+{
+	const struct client *a = _a;
+	const struct client *b = _b;
+	int pid_a, pid_b;
+
+	pid_a = a->status == ALIVE ? a->pid : INT_MAX;
+	pid_b = b->status == ALIVE ? b->pid : INT_MAX;
+
+	pid_b -= pid_a;
+	if (pid_b > 0)
+		return -1;
+	if (pid_b < 0)
+		return 1;
+
+	return (int)a->id - b->id;
+}
+
+static int (*client_cmp)(const void *, const void *) = client_last_cmp;
+
+static struct clients *sort_clients(struct clients *clients,
+				    int (*cmp)(const void *, const void *))
+{
+	unsigned int active, free;
+	struct client *c;
+	int tmp;
+
+	if (!clients)
+		return clients;
+
+	qsort(clients->client, clients->num_clients, sizeof(*clients->client),
+	      cmp);
+
+	/* Trim excessive array space. */
+	active = 0;
+	for_each_client(clients, c, tmp) {
+		if (c->status != ALIVE)
+			break; /* Active clients are first in the array. */
+		active++;
+	}
+
+	clients->active_clients = active;
+
+	free = clients->num_clients - active;
+	if (free > clients->num_clients / 2) {
+		active = clients->num_clients - free / 2;
+		if (active != clients->num_clients) {
+			clients->num_clients = active;
+			clients->client = realloc(clients->client,
+						  clients->num_clients *
+						  sizeof(*c));
+		}
+	}
+
+	return clients;
+}
+
+static bool aggregate_pids = true;
+
+static struct clients *display_clients(struct clients *clients)
+{
+	struct client *ac, *c, *cp = NULL;
+	struct clients *aggregated;
+	int tmp, num = 0;
+
+	if (!aggregate_pids)
+		goto out;
+
+	/* Sort by pid first to make it easy to aggregate while walking. */
+	sort_clients(clients, client_pid_cmp);
+
+	aggregated = calloc(1, sizeof(*clients));
+	assert(aggregated);
+
+	ac = calloc(clients->num_clients, sizeof(*c));
+	assert(ac);
+
+	aggregated->num_classes = clients->num_classes;
+	aggregated->class = clients->class;
+	aggregated->client = ac;

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 940

Quoted 10 lines
tools/intel_gpu_top.c +10 -0
+
+	for_each_client(clients, c, tmp) {
+		unsigned int i;
+
+		if (c->status == FREE)
+			break;
+
+		assert(c->status == ALIVE);
+
+		if ((cp && c->pid != cp->pid) || !cp) {

same as: if (!cp || c->pid != cp->pid), fine either ways

Quoted 61 lines
tools/intel_gpu_top.c +61 -0
+			ac = &aggregated->client[num++];
+
+			/* New pid. */
+			ac->clients = aggregated;
+			ac->status = ALIVE;
+			ac->id = -c->pid;
+			ac->pid = c->pid;
+			strcpy(ac->name, c->name);
+			strcpy(ac->print_name, c->print_name);
+			ac->val = calloc(clients->num_classes,
+					 sizeof(ac->val[0]));
+			assert(ac->val);
+			ac->samples = 1;
+		}
+
+		cp = c;
+
+		if (c->samples < 2)
+			continue;
+
+		ac->samples = 2; /* All what matters for display. */
+		ac->total_runtime += c->total_runtime;
+		ac->last_runtime += c->last_runtime;
+
+		for (i = 0; i < clients->num_classes; i++)
+			ac->val[i] += c->val[i];
+	}
+
+	aggregated->num_clients = num;
+	aggregated->active_clients = num;
+
+	clients = aggregated;
+
+out:
+	return sort_clients(clients, client_cmp);
+}
+
+static void free_clients(struct clients *clients)
+{
+	struct client *c;
+	unsigned int tmp;
+
+	for_each_client(clients, c, tmp) {
+		free(c->val);
+		free(c->last);
+	}
+
+	free(clients->client);
+	free(clients);
+}
+
+static bool is_drm_fd(DIR *fd_dir, const char *name)
+{
+	struct stat stat;
+	int ret;
+
+	ret = fstatat(dirfd(fd_dir), name, &stat, 0);
+
+	return ret == 0 &&
+	       (stat.st_mode & S_IFMT) == S_IFCHR &&
+	       major(stat.st_rdev) == 226;

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 1011

Quoted 10 lines
tools/intel_gpu_top.c +10 -0
+}
+
+static bool get_task_name(const char *buffer, char *out, unsigned long sz)
+{
+	char *s = index(buffer, '(');
+	char *e = rindex(buffer, ')');
+	unsigned int len;
+
+	if (!s || !e)
+		return false;

maybe assert(e > s);

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 1013

Quoted 2 lines
tools/intel_gpu_top.c +2 -0
+
+	len = --e - ++s + 1;

len = e - ++s;

Thanks,
Umesh

#9 lore raw

Re: [igt-dev] [PATCH i-g-t 03/11] intel-gpu-top: Add support for per client stats

Quoted 5 lines · Umesh Nerlige Ramappa

lgtm, I just have a few nits and questions below:

Regardless, this is

Thanks!

I've sent the updated series with only first three patches for first stage. Only first patch misses the r-b now.

Rest of the comments below.

Quoted 172 lines · Tvrtko Ursulin
Quoted 171 lines

From: Tvrtko Ursulin <[email protected]>

Use the i915 exported data in /proc/<pid>/fdinfo to show GPU utilization per DRM client.

Example of the output:

intel-gpu-top: Intel Tigerlake (Gen12) @ /dev/dri/card0 -  220/ 221 MHz 70% RC6;  0.62/ 7.08 W;      760 irqs/s

        ENGINES     BUSY                                 MI_SEMA MI_WAIT Render/3D   23.06% |██████▊                      |      0%      0% Blitter    0.00% |                             |      0%      0% Video    5.40% |█▋                           |      0%      0% VideoEnhance   20.67% |██████                       |      0%      0%

  PID              NAME  Render/3D    Blitter      Video    VideoEnhance 3082               mpv |          ||          ||▌         ||██        | 3117         neverball |█▉        ||          ||          ||          | 1           systemd |▍         ||          ||          ||          | 2338       gnome-shell |          ||          ||          ||          |

---
man/intel_gpu_top.rst |   4 +
tools/intel_gpu_top.c | 801 +++++++++++++++++++++++++++++++++++++++++- tools/meson.build     |   2 +-

3 files changed, 804 insertions(+), 3 deletions(-)
man/intel_gpu_top.rst +0 -0
index b3b765b05feb..f4dbfc5b44d9 100644
@@ -56,6 +56,10 @@ Supported keys:

    'q'    Exit from the tool.
    'h'    Show interactive help.
    '1'    Toggle between aggregated engine class and physical engine mode. +    'n'    Toggle display of numeric client busyness overlay. +    's'    Toggle between sort modes (runtime, total runtime, pid, client id).
+    'i'    Toggle display of clients which used no GPU time.
+    'H'    Toggle between per PID aggregation and individual clients.

DEVICE SELECTION
================

tools/intel_gpu_top.c +4 -1
index bc11fce2bb1e..73815cdea8aa 100644
@@ -43,8 +43,10 @@
 #include <sys/types.h>
 #include <unistd.h>
 #include <termios.h>
+#include <sys/sysmacros.h>
 
 #include "igt_perf.h"
+#include "igt_drm_fdinfo.h"
 
 #define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
 
@@ -311,7 +313,8 @@ static int engine_cmp(const void *__a, const void 
 *__b)
         return a->instance - b->instance;
 }
 
-#define is_igpu_pci(x) (strcmp(x, "0000:00:02.0") == 0)
+#define IGPU_PCI "0000:00:02.0"
+#define is_igpu_pci(x) (strcmp(x, IGPU_PCI) == 0)
 #define is_igpu(x) (strcmp(x, "i915") == 0)
 

static struct engines *discover_engines(char *device)

tools/intel_gpu_top.c +61 -0
@@ -635,6 +638,547 @@ static void pmu_sample(struct engines *engines)
     }
 }
 
+enum client_status {
+    FREE = 0, /* mbz */
+    ALIVE,
+    PROBE
+};
+
+struct clients;
+
+struct client {
+    struct clients *clients;
+
+    enum client_status status;
+    unsigned int id;
+    unsigned int pid;
+    char name[24];
+    char print_name[24];
+    unsigned int samples;
+    unsigned long total_runtime;
+    unsigned long last_runtime;
+    unsigned long *val;
+    uint64_t *last;
+};
+
+struct clients {
+    unsigned int num_clients;
+    unsigned int active_clients;
+
+    unsigned int num_classes;
+    struct engine_class *class;
+
+    char pci_slot[64];
+
+    struct client *client;
+};
+
+#define for_each_client(clients, c, tmp) \
+    for ((tmp) = (clients)->num_clients, c = (clients)->client; \
+         (tmp > 0); (tmp)--, (c)++)
+
+static struct clients *init_clients(const char *pci_slot)
+{
+    struct clients *clients;
+
+    clients = malloc(sizeof(*clients));
+    if (!clients)
+        return NULL;
+
+    memset(clients, 0, sizeof(*clients));
+
+    strncpy(clients->pci_slot, pci_slot, sizeof(clients->pci_slot));
+
+    return clients;
+}
+
+static struct client *
+find_client(struct clients *clients, enum client_status status, 
 unsigned int id)
+{
+    unsigned int start, num;
+    struct client *c;
+
+    start = status == FREE ? clients->active_clients : 0; /* Free 

block at the end. */
+    num = clients->num_clients - start;

tools/intel_gpu_top.c +14 -0
+
+    for (c = &clients->client[start]; num; c++, num--) {
+        if (status != c->status)
+            continue;
+
+        if (status == FREE || c->id == id)
+            return c;
+    }
+
+    return NULL;
+}
+
+static void
+update_client(struct client *c, unsigned int pid, char *name, 

uint64_t val[16])

tools/intel_gpu_top.c +17 -0
+{
+    unsigned int i;
+
+    if (c->pid != pid)
+        c->pid = pid;
+
+    if (strcmp(c->name, name)) {
+        char *p;
+
+        strncpy(c->name, name, sizeof(c->name) - 1);
+        strncpy(c->print_name, name, sizeof(c->print_name) - 1);
+
+        p = c->print_name;
+        while (*p) {
+            if (!isprint(*p))
+                *p = '*';
+            p++;
Quoted 8 lines

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 739

Quoted 6 lines

+        }
+    }

tools/intel_gpu_top.c +4 -0
+
+    c->last_runtime = 0;
+    c->total_runtime = 0;
+

assert(c->clients->num_classes <= 16);

Done in a slightly different way - since I've changed the function signature to take struct drm_client_fdinfo I used ARRAY_SIZE on the busy array inside it.

Quoted 6 lines
Quoted 6 lines

+    for (i = 0; i < c->clients->num_classes; i++) { +        if (val[i] < c->last[i])
+            continue; /* It will catch up soon. */ +
+        c->total_runtime += val[i];

Quoted 6 lines

As far as busyness is concerned c->total_runtime += val[i] should be it.

Quoted 3 lines

+        c->val[i] = val[i] - c->last[i];
+        c->last_runtime += c->val[i];
+        c->last[i] = val[i];

Can you describe what these 3 lines are doing?

For different sorting modes I need to be able to put at the top the most active client regardless of which engines.

c->total_runtime is cumulative across engine usage.

c->last_runtime is usage during the last display period, also all engines added together.

c->last[] is simply tracking the delta per engine, from last display period to current, so relative utilisation in the last display period can be displayed.

Quoted 71 lines
Quoted 58 lines

+    }

tools/intel_gpu_top.c +50 -0
+
+    c->samples++;
+    c->status = ALIVE;
+}
+
+static void
+add_client(struct clients *clients, unsigned int id, unsigned int pid,
+       char *name, uint64_t busy[16])
+{
+    struct client *c;
+
+    assert(!find_client(clients, ALIVE, id));
+
+    c = find_client(clients, FREE, 0);
+    if (!c) {
+        unsigned int idx = clients->num_clients;
+
+        clients->num_clients += (clients->num_clients + 2) / 2;
+        clients->client = realloc(clients->client,
+                      clients->num_clients * sizeof(*c));
+        assert(clients->client);
+
+        c = &clients->client[idx];
+        memset(c, 0, (clients->num_clients - idx) * sizeof(*c));
+    }
+
+    c->id = id;
+    c->clients = clients;
+    c->val = calloc(clients->num_classes, sizeof(c->val));
+    c->last = calloc(clients->num_classes, sizeof(c->last));
+    assert(c->val && c->last);
+
+    update_client(c, pid, name, busy);
+}
+
+static void free_client(struct client *c)
+{
+    free(c->val);
+    free(c->last);
+    memset(c, 0, sizeof(*c));
+}
+
+static int client_last_cmp(const void *_a, const void *_b)
+{
+    const struct client *a = _a;
+    const struct client *b = _b;
+    long tot_a, tot_b;
+
+    /*
+     * Sort clients in descending order of runtime in the previous 

sampling
+     * period for active ones, followed by inactive. Tie-breaker is client
+     * id.
+     */

tools/intel_gpu_top.c +1 -0
+

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 812

Quoted 10 lines
tools/intel_gpu_top.c +10 -0
+    tot_a = a->status == ALIVE ? a->last_runtime : -1;
+    tot_b = b->status == ALIVE ? b->last_runtime : -1;
+
+    tot_b -= tot_a;
+    if (tot_b > 0)
+        return 1;
+    if (tot_b < 0)
+        return -1;
+
+    return (int)b->id - a->id;

nit: the compare functions could use a single if, if you agree on just returning tot_b.

Quoted 4 lines

    if (!tot_b)
        return (int)b->id - a->id;

    return tot_b;

I chose not to touch this for now. It gets refactored later in the series and there are signed extending issues (compare function works with int result while my internal data are alongs) to think about so I'd rather not need to re-debug it.

Quoted 123 lines
Quoted 123 lines
tools/intel_gpu_top.c +69 -0
+}
+
+static int client_total_cmp(const void *_a, const void *_b)
+{
+    const struct client *a = _a;
+    const struct client *b = _b;
+    long tot_a, tot_b;
+
+    tot_a = a->status == ALIVE ? a->total_runtime : -1;
+    tot_b = b->status == ALIVE ? b->total_runtime : -1;
+
+    tot_b -= tot_a;
+    if (tot_b > 0)
+        return 1;
+    if (tot_b < 0)
+        return -1;
+
+    return (int)b->id - a->id;
+}
+
+static int client_id_cmp(const void *_a, const void *_b)
+{
+    const struct client *a = _a;
+    const struct client *b = _b;
+    int id_a, id_b;
+
+    id_a = a->status == ALIVE ? a->id : -1;
+    id_b = b->status == ALIVE ? b->id : -1;
+
+    id_b -= id_a;
+    if (id_b > 0)
+        return 1;
+    if (id_b < 0)
+        return -1;
+
+    return (int)b->id - a->id;
+}
+
+static int client_pid_cmp(const void *_a, const void *_b)
+{
+    const struct client *a = _a;
+    const struct client *b = _b;
+    int pid_a, pid_b;
+
+    pid_a = a->status == ALIVE ? a->pid : INT_MAX;
+    pid_b = b->status == ALIVE ? b->pid : INT_MAX;
+
+    pid_b -= pid_a;
+    if (pid_b > 0)
+        return -1;
+    if (pid_b < 0)
+        return 1;
+
+    return (int)a->id - b->id;
+}
+
+static int (*client_cmp)(const void *, const void *) = client_last_cmp;
+
+static struct clients *sort_clients(struct clients *clients,
+                    int (*cmp)(const void *, const void *))
+{
+    unsigned int active, free;
+    struct client *c;
+    int tmp;
+
+    if (!clients)
+        return clients;
+
+    qsort(clients->client, clients->num_clients, 

sizeof(*clients->client),
+          cmp);

tools/intel_gpu_top.c +52 -0
+
+    /* Trim excessive array space. */
+    active = 0;
+    for_each_client(clients, c, tmp) {
+        if (c->status != ALIVE)
+            break; /* Active clients are first in the array. */
+        active++;
+    }
+
+    clients->active_clients = active;
+
+    free = clients->num_clients - active;
+    if (free > clients->num_clients / 2) {
+        active = clients->num_clients - free / 2;
+        if (active != clients->num_clients) {
+            clients->num_clients = active;
+            clients->client = realloc(clients->client,
+                          clients->num_clients *
+                          sizeof(*c));
+        }
+    }
+
+    return clients;
+}
+
+static bool aggregate_pids = true;
+
+static struct clients *display_clients(struct clients *clients)
+{
+    struct client *ac, *c, *cp = NULL;
+    struct clients *aggregated;
+    int tmp, num = 0;
+
+    if (!aggregate_pids)
+        goto out;
+
+    /* Sort by pid first to make it easy to aggregate while walking. */
+    sort_clients(clients, client_pid_cmp);
+
+    aggregated = calloc(1, sizeof(*clients));
+    assert(aggregated);
+
+    ac = calloc(clients->num_clients, sizeof(*c));
+    assert(ac);
+
+    aggregated->num_classes = clients->num_classes;
+    aggregated->class = clients->class;
+    aggregated->client = ac;
+
+    for_each_client(clients, c, tmp) {
+        unsigned int i;
+
Quoted 8 lines

tools/intel_gpu_top.c static void pmu_sample(struct engines *engines) · line 940

Quoted 6 lines

+        if (c->status == FREE)
+            break;

tools/intel_gpu_top.c +4 -0
+
+        assert(c->status == ALIVE);
+
+        if ((cp && c->pid != cp->pid) || !cp) {

same as: if (!cp || c->pid != cp->pid), fine either ways

Yep thanks, done.

Quoted 67 lines
Quoted 67 lines

+            ac = &aggregated->client[num++];

tools/intel_gpu_top.c +63 -0
+
+            /* New pid. */
+            ac->clients = aggregated;
+            ac->status = ALIVE;
+            ac->id = -c->pid;
+            ac->pid = c->pid;
+            strcpy(ac->name, c->name);
+            strcpy(ac->print_name, c->print_name);
+            ac->val = calloc(clients->num_classes,
+                     sizeof(ac->val[0]));
+            assert(ac->val);
+            ac->samples = 1;
+        }
+
+        cp = c;
+
+        if (c->samples < 2)
+            continue;
+
+        ac->samples = 2; /* All what matters for display. */
+        ac->total_runtime += c->total_runtime;
+        ac->last_runtime += c->last_runtime;
+
+        for (i = 0; i < clients->num_classes; i++)
+            ac->val[i] += c->val[i];
+    }
+
+    aggregated->num_clients = num;
+    aggregated->active_clients = num;
+
+    clients = aggregated;
+
+out:
+    return sort_clients(clients, client_cmp);
+}
+
+static void free_clients(struct clients *clients)
+{
+    struct client *c;
+    unsigned int tmp;
+
+    for_each_client(clients, c, tmp) {
+        free(c->val);
+        free(c->last);
+    }
+
+    free(clients->client);
+    free(clients);
+}
+
+static bool is_drm_fd(DIR *fd_dir, const char *name)
+{
+    struct stat stat;
+    int ret;
+
+    ret = fstatat(dirfd(fd_dir), name, &stat, 0);
+
+    return ret == 0 &&
+           (stat.st_mode & S_IFMT) == S_IFCHR &&
+           major(stat.st_rdev) == 226;
+}
+
+static bool get_task_name(const char *buffer, char *out, unsigned 

long sz)
+{

Quoted 8 lines
Quoted 6 lines

+    char *s = index(buffer, '(');
+    char *e = rindex(buffer, ')');
+    unsigned int len;
+
+    if (!s || !e)
+        return false;

maybe assert(e > s);

Done.

Quoted 5 lines
Quoted 3 lines

+
+    len = --e - ++s + 1;

len = e - ++s;

Not sure which one is more readable, depends how you think about it I guess. But done nevertheless.

Regards,

Tvrtko

#10 lore raw

PATCH 4/11 lib: Extract igt_drm_clients from intel_gpu_top

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Code movement with some improvements to prepare for further work in making a vendor agnostic gputop tool possible.

---
 lib/igt_drm_clients.c | 386 +++++++++++++++++++++++++++++++
 lib/igt_drm_clients.h | 102 +++++++++
 lib/meson.build       |   8 +
 tools/intel_gpu_top.c | 516 ++++++------------------------------------
 tools/meson.build     |   2 +-
 5 files changed, 570 insertions(+), 444 deletions(-)
 create mode 100644 lib/igt_drm_clients.c
 create mode 100644 lib/igt_drm_clients.h
lib/igt_drm_clients.c new file +386 -0
new file mode 100644
index 000000000000..58d82648d821
@@ -0,0 +1,386 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ *
+ */
+
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/sysmacros.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "igt_drm_clients.h"
+#include "igt_drm_fdinfo.h"
+
+struct igt_drm_clients *igt_drm_clients_init(void *private_data)
+{
+	struct igt_drm_clients *clients;
+
+	clients = malloc(sizeof(*clients));
+	if (!clients)
+		return NULL;
+
+	memset(clients, 0, sizeof(*clients));
+
+	clients->private_data = private_data;
+
+	return clients;
+}
+
+struct igt_drm_client *
+igt_drm_clients_find(struct igt_drm_clients *clients,
+		     enum igt_drm_client_status status,
+		     unsigned int id)
+{
+	unsigned int start, num;
+	struct igt_drm_client *c;
+
+	start = status == IGT_DRM_CLIENT_FREE ? clients->active_clients : 0; /* Free block at the end. */
+	num = clients->num_clients - start;
+
+	for (c = &clients->client[start]; num; c++, num--) {
+		if (status != c->status)
+			continue;
+
+		if (status == IGT_DRM_CLIENT_FREE || c->id == id)
+			return c;
+	}
+
+	return NULL;
+}
+
+void
+igt_drm_client_update(struct igt_drm_client *c, unsigned int pid, char *name,
+		      uint64_t val[16])
+{
+	unsigned int i;
+
+	if (c->pid != pid)
+		c->pid = pid;
+
+	if (strcmp(c->name, name)) {
+		char *p;
+
+		strncpy(c->name, name, sizeof(c->name) - 1);
+		strncpy(c->print_name, name, sizeof(c->print_name) - 1);
+
+		p = c->print_name;
+		while (*p) {
+			if (!isprint(*p))
+				*p = '*';
+			p++;
+		}
+	}
+
+	c->last_runtime = 0;
+	c->total_runtime = 0;
+
+	for (i = 0; i < c->clients->num_classes; i++) {
+		if (val[i] < c->last[i])
+			continue; /* It will catch up soon. */
+
+		c->total_runtime += val[i];
+		c->val[i] = val[i] - c->last[i];
+		c->last_runtime += c->val[i];
+		c->last[i] = val[i];
+	}
+
+	c->samples++;
+	c->status = IGT_DRM_CLIENT_ALIVE;
+}
+
+void
+igt_drm_client_add(struct igt_drm_clients *clients, unsigned int id,
+		   unsigned int pid, char *name, uint64_t busy[16])
+{
+	struct igt_drm_client *c;
+
+	assert(!igt_drm_clients_find(clients, IGT_DRM_CLIENT_ALIVE, id));
+
+	c = igt_drm_clients_find(clients, IGT_DRM_CLIENT_FREE, 0);
+	if (!c) {
+		unsigned int idx = clients->num_clients;
+
+		clients->num_clients += (clients->num_clients + 2) / 2;
+		clients->client = realloc(clients->client,
+					  clients->num_clients * sizeof(*c));
+		assert(clients->client);
+
+		c = &clients->client[idx];
+		memset(c, 0, (clients->num_clients - idx) * sizeof(*c));
+	}
+
+	c->id = id;
+	c->clients = clients;
+	c->val = calloc(clients->num_classes, sizeof(c->val));
+	c->last = calloc(clients->num_classes, sizeof(c->last));
+	assert(c->val && c->last);
+
+	igt_drm_client_update(c, pid, name, busy);
+}
+
+void igt_drm_client_free(struct igt_drm_client *c)
+{
+	free(c->val);
+	free(c->last);
+	memset(c, 0, sizeof(*c));
+}
+
+struct igt_drm_clients *
+igt_drm_clients_sort(struct igt_drm_clients *clients,
+		     int (*cmp)(const void *, const void *))
+{
+	unsigned int active, free;
+	struct igt_drm_client *c;
+	int tmp;
+
+	if (!clients)
+		return clients;
+
+	qsort(clients->client, clients->num_clients, sizeof(*clients->client),
+	      cmp);
+
+	/* Trim excessive array space. */
+	active = 0;
+	igt_for_each_drm_client(clients, c, tmp) {
+		if (c->status != IGT_DRM_CLIENT_ALIVE)
+			break; /* Active clients are first in the array. */
+		active++;
+	}
+
+	clients->active_clients = active;
+
+	free = clients->num_clients - active;
+	if (free > clients->num_clients / 2) {
+		active = clients->num_clients - free / 2;
+		if (active != clients->num_clients) {
+			clients->num_clients = active;
+			clients->client = realloc(clients->client,
+						  clients->num_clients *
+						  sizeof(*c));
+		}
+	}
+
+	return clients;
+}
+
+void igt_drm_clients_free(struct igt_drm_clients *clients)
+{
+	struct igt_drm_client *c;
+	unsigned int tmp;
+
+	igt_for_each_drm_client(clients, c, tmp)
+		igt_drm_client_free(c);
+
+	free(clients->client);
+	free(clients);
+}
+
+static DIR *opendirat(int at, const char *name)
+{
+	DIR *dir;
+	int fd;
+
+	fd = openat(at, name, O_DIRECTORY);
+	if (fd < 0)
+		return NULL;
+
+	dir = fdopendir(fd);
+	if (!dir)
+		close(fd);
+
+	return dir;
+}
+
+static size_t readat2buf(char *buf, const size_t sz, int at, const char *name)
+{
+	size_t count;
+	int fd;
+
+	fd = openat(at, name, O_RDONLY);
+	if (fd < 0)
+		return 0;
+
+	buf[sz - 1] = 0;
+	count = read(fd, buf, sz);
+	close(fd);
+
+	return count;
+}
+
+static bool get_task_name(const char *buffer, char *out, unsigned long sz)
+{
+	char *s = index(buffer, '(');
+	char *e = rindex(buffer, ')');
+	unsigned int len;
+
+	if (!s || !e)
+		return false;
+
+	len = --e - ++s + 1;
+	if(!len || (len + 1) >= sz)
+		return false;
+
+	strncpy(out, s, len);
+	out[len] = 0;
+
+	return true;
+}
+
+static bool is_drm_fd(int fd_dir, const char *name)
+{
+	struct stat stat;
+	int ret;
+
+	ret = fstatat(fd_dir, name, &stat, 0);
+
+	return ret == 0 &&
+	       (stat.st_mode & S_IFMT) == S_IFCHR &&
+	       major(stat.st_rdev) == 226;
+}
+
+struct igt_drm_clients *
+igt_drm_clients_scan(struct igt_drm_clients *clients,
+		     bool (*filter_client)(const struct igt_drm_clients *,
+					   const struct drm_client_fdinfo *))
+{
+	struct dirent *proc_dent;
+	struct igt_drm_client *c;
+	DIR *proc_dir;
+	int tmp;
+
+	if (!clients)
+		return clients;
+
+	igt_for_each_drm_client(clients, c, tmp) {
+		assert(c->status != IGT_DRM_CLIENT_PROBE);
+		if (c->status == IGT_DRM_CLIENT_ALIVE)
+			c->status = IGT_DRM_CLIENT_PROBE;
+		else
+			break; /* Free block at the end of array. */
+	}
+
+	proc_dir = opendir("/proc");
+	if (!proc_dir)
+		return clients;
+
+	while ((proc_dent = readdir(proc_dir)) != NULL) {
+		int pid_dir = -1, fd_dir = -1;
+		struct dirent *fdinfo_dent;
+		char client_name[64] = { };
+		unsigned int client_pid;
+		DIR *fdinfo_dir = NULL;
+		char buf[4096];
+		size_t count;
+
+		if (proc_dent->d_type != DT_DIR)
+			continue;
+		if (!isdigit(proc_dent->d_name[0]))
+			continue;
+
+		pid_dir = openat(dirfd(proc_dir), proc_dent->d_name,
+				 O_DIRECTORY | O_RDONLY);
+		if (pid_dir < 0)
+			continue;
+
+		count = readat2buf(buf, sizeof(buf), pid_dir, "stat");
+		if (!count)
+			goto next;
+
+		client_pid = atoi(buf);
+		if (!client_pid)
+			goto next;
+
+		if (!get_task_name(buf, client_name, sizeof(client_name)))
+			goto next;
+
+		fd_dir = openat(pid_dir, "fd", O_DIRECTORY | O_RDONLY);
+		if (fd_dir < 0)
+			goto next;
+
+		fdinfo_dir = opendirat(pid_dir, "fdinfo");
+		if (!fdinfo_dir)
+			goto next;
+
+		while ((fdinfo_dent = readdir(fdinfo_dir)) != NULL) {
+			struct drm_client_fdinfo info;
+
+			if (fdinfo_dent->d_type != DT_REG)
+				continue;
+			if (!isdigit(fdinfo_dent->d_name[0]))
+				continue;
+
+			if (!is_drm_fd(fd_dir, fdinfo_dent->d_name))
+				continue;
+
+			memset(&info, 0, sizeof(info));
+
+			if (!__igt_parse_drm_fdinfo(dirfd(fdinfo_dir),
+						    fdinfo_dent->d_name,
+						    &info))
+				continue;
+
+			if (filter_client && !filter_client(clients, &info))
+				continue;
+
+			if (igt_drm_clients_find(clients, IGT_DRM_CLIENT_ALIVE,
+						info.id))
+				continue; /* Skip duplicate fds. */
+
+			c = igt_drm_clients_find(clients, IGT_DRM_CLIENT_PROBE,
+						info.id);
+			if (!c)
+				igt_drm_client_add(clients, info.id, client_pid,
+						   client_name, info.busy);
+			else
+				igt_drm_client_update(c, client_pid,
+						      client_name, info.busy);
+		}
+
+next:
+		if (fdinfo_dir)
+			closedir(fdinfo_dir);
+		if (fd_dir >= 0)
+			close(fd_dir);
+		if (pid_dir >= 0)
+			close(pid_dir);
+	}
+
+	closedir(proc_dir);
+
+	igt_for_each_drm_client(clients, c, tmp) {
+		if (c->status == IGT_DRM_CLIENT_PROBE)
+			igt_drm_client_free(c);
+		else if (c->status == IGT_DRM_CLIENT_FREE)
+			break;
+	}
+
+	return clients;
+}
lib/igt_drm_clients.h new file +102 -0

102 lines not on this page · raw message

lib/meson.build +8 -0
index d00817dc58bc..131bb749ed85 100644
@@ -16,6 +16,7 @@ lib_sources = [
 	'igt_debugfs.c',
 	'igt_device.c',
 	'igt_device_scan.c',
+	'igt_drm_clients.h',
 	'igt_drm_fdinfo.c',
 	'igt_aux.c',
 	'igt_gt.c',
@@ -217,6 +218,13 @@ lib_igt_device_scan_build = static_library('igt_device_scan',
 lib_igt_device_scan = declare_dependency(link_with : lib_igt_device_scan_build,
 				  include_directories : inc)
 
+lib_igt_drm_clients_build = static_library('igt_drm_clients',
+        ['igt_drm_clients.c'],
+        include_directories : inc)
+
+lib_igt_drm_clients = declare_dependency(link_with : lib_igt_drm_clients_build,
+				         include_directories : inc)
+
 lib_igt_drm_fdinfo_build = static_library('igt_drm_fdinfo',
 	['igt_drm_fdinfo.c'],
 	include_directories : inc)
tools/intel_gpu_top.c +73 -443

731 lines not on this page · raw message

tools/meson.build +1 -1
index 771d0b9e3d5d..e65aceeef9fa 100644
@@ -91,7 +91,7 @@ install_subdir('registers', install_dir : datadir)
 executable('intel_gpu_top', 'intel_gpu_top.c',
 	   install : true,
 	   install_rpath : bindir_rpathdir,
-	   dependencies : [lib_igt_perf,lib_igt_device_scan,lib_igt_drm_fdinfo,math])
+	   dependencies : [lib_igt_perf,lib_igt_device_scan,lib_igt_drm_clients,lib_igt_drm_fdinfo,math])
 
 executable('amd_hdmi_compliance', 'amd_hdmi_compliance.c',
 	   dependencies : [tool_deps],
Signature · 1 line
2.32.0
#11 lore raw

PATCH 5/11 libdrmfdinfo: Allow specifying custom engine map

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Instead of hard coding the engine names, allow a map of names to indices to either be passed in or it gets auto-detected (less efficient) while parsing.

---
 lib/igt_drm_clients.c   |  7 +++---
 lib/igt_drm_clients.h   |  3 ++-
 lib/igt_drm_fdinfo.c    | 47 +++++++++++++++++++++++++++--------------
 lib/igt_drm_fdinfo.h    |  7 ++++--
 tests/i915/drm_fdinfo.c | 16 +++++++++++---
 tools/intel_gpu_top.c   | 13 ++++++++++--
 6 files changed, 66 insertions(+), 27 deletions(-)
lib/igt_drm_clients.c +4 -3
index 58d82648d821..591602f4c9f5 100644
@@ -269,7 +269,8 @@ static bool is_drm_fd(int fd_dir, const char *name)
 struct igt_drm_clients *
 igt_drm_clients_scan(struct igt_drm_clients *clients,
 		     bool (*filter_client)(const struct igt_drm_clients *,
-					   const struct drm_client_fdinfo *))
+					   const struct drm_client_fdinfo *),
+		     const char **name_map, unsigned int map_entries)
 {
 	struct dirent *proc_dent;
 	struct igt_drm_client *c;
@@ -343,8 +344,8 @@ igt_drm_clients_scan(struct igt_drm_clients *clients,
 			memset(&info, 0, sizeof(info));
 
 			if (!__igt_parse_drm_fdinfo(dirfd(fdinfo_dir),
-						    fdinfo_dent->d_name,
-						    &info))
+						    fdinfo_dent->d_name, &info,
+						    name_map, map_entries))
 				continue;
 
 			if (filter_client && !filter_client(clients, &info))
lib/igt_drm_clients.h +2 -1
index f52080847291..91e9da4c0733 100644
@@ -80,7 +80,8 @@ void igt_drm_clients_free(struct igt_drm_clients *clients);
 struct igt_drm_clients *
 igt_drm_clients_scan(struct igt_drm_clients *clients,
 		     bool (*filter_client)(const struct igt_drm_clients *,
-					   const struct drm_client_fdinfo *));
+					   const struct drm_client_fdinfo *),
+		     const char **name_map, unsigned int map_entries);
 
 struct igt_drm_client *
 igt_drm_clients_find(struct igt_drm_clients *clients,
lib/igt_drm_fdinfo.c +31 -16

96 lines not on this page · raw message

lib/igt_drm_fdinfo.h +5 -2
index c527bab9a204..bea4a6304734 100644
@@ -37,12 +37,15 @@ struct drm_client_fdinfo {
 
 	unsigned int num_engines;
 	unsigned int capacity[16];
+	char names[16][256];
 	uint64_t busy[16];
 };
 
-bool igt_parse_drm_fdinfo(int drm_fd, struct drm_client_fdinfo *info);
+bool igt_parse_drm_fdinfo(int drm_fd, struct drm_client_fdinfo *info,
+			  const char **name_map, unsigned int map_entries);
 
 bool __igt_parse_drm_fdinfo(int dir, const char *fd,
-			    struct drm_client_fdinfo *info);
+			    struct drm_client_fdinfo *info,
+			    const char **name_map, unsigned int map_entries);
 
 #endif /* IGT_DRM_FDINFO_H */
tests/i915/drm_fdinfo.c +13 -3
index e3b1ebb0f454..d1053a53ae2c 100644
@@ -34,6 +34,13 @@ IGT_TEST_DESCRIPTION("Test the i915 drm fdinfo data");
 const double tolerance = 0.05f;
 const unsigned long batch_duration_ns = 500e6;
 
+static const char *engine_map[] = {
+	"render",
+	"copy",
+	"video",
+	"video-enhance",
+};
+
 #define __assert_within_epsilon(x, ref, tol_up, tol_down) \
 	igt_assert_f((double)(x) <= (1.0 + (tol_up)) * (double)(ref) && \
 		     (double)(x) >= (1.0 - (tol_down)) * (double)(ref), \
@@ -50,7 +57,8 @@ static void basics(int i915, unsigned int num_classes)
 	struct drm_client_fdinfo info = { };
 	bool ret;
 
-	ret = igt_parse_drm_fdinfo(i915, &info);
+	ret = igt_parse_drm_fdinfo(i915, &info, engine_map,
+				   ARRAY_SIZE(engine_map));
 	igt_assert(ret);
 
 	igt_assert(!strcmp(info.driver, "i915"));
@@ -181,7 +189,8 @@ static uint64_t read_busy(int i915, unsigned int class)
 {
 	struct drm_client_fdinfo info = { };
 
-	igt_assert(igt_parse_drm_fdinfo(i915, &info));
+	igt_assert(igt_parse_drm_fdinfo(i915, &info, engine_map,
+					ARRAY_SIZE(engine_map)));
 
 	return info.busy[class];
 }
@@ -267,7 +276,8 @@ static void read_busy_all(int i915, uint64_t *val)
 {
 	struct drm_client_fdinfo info = { };
 
-	igt_assert(igt_parse_drm_fdinfo(i915, &info));
+	igt_assert(igt_parse_drm_fdinfo(i915, &info, engine_map,
+					ARRAY_SIZE(engine_map)));
 
 	memcpy(val, info.busy, sizeof(info.busy));
 }
tools/intel_gpu_top.c +11 -2
index c4f990b2a7d0..99e8e1d8ffd4 100644
@@ -2030,6 +2030,12 @@ int main(int argc, char **argv)
 {
 	unsigned int period_us = DEFAULT_PERIOD_MS * 1000;
 	struct igt_drm_clients *clients = NULL;
+	static const char *engine_map[] = {
+		"render",
+		"copy",
+		"video",
+		"video-enhance",
+	};
 	int con_w = -1, con_h = -1;
 	char *output_path = NULL;
 	struct engines *engines;
@@ -2177,7 +2183,8 @@ int main(int argc, char **argv)
 	}
 
 	pmu_sample(engines);
-	igt_drm_clients_scan(clients, client_match);
+	igt_drm_clients_scan(clients, client_match, engine_map,
+			     ARRAY_SIZE(engine_map));
 	codename = igt_device_get_pretty_name(&card, false);
 
 	while (!stop_top) {
@@ -2206,7 +2213,9 @@ int main(int argc, char **argv)
 
 		disp_clients =
 			display_clients(igt_drm_clients_scan(clients,
-							     client_match));
+							     client_match,
+							     engine_map,
+							     ARRAY_SIZE(engine_map)));
 
 		if (stop_top)
 			break;
Signature · 1 line
2.32.0
#12 lore raw

PATCH 6/11 libdrmclients: Record client drm minor

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Prepare for supporting clients belonging to multiple DRM cards by storing the DRM minor in the client record.

---
 lib/igt_drm_clients.c | 33 ++++++++++++++++++++-------------
 lib/igt_drm_clients.h |  6 ++++--
 2 files changed, 24 insertions(+), 15 deletions(-)
lib/igt_drm_clients.c +20 -13
index 591602f4c9f5..116479a9f363 100644
@@ -117,12 +117,13 @@ igt_drm_client_update(struct igt_drm_client *c, unsigned int pid, char *name,
 }
 
 void
-igt_drm_client_add(struct igt_drm_clients *clients, unsigned int id,
-		   unsigned int pid, char *name, uint64_t busy[16])
+igt_drm_client_add(struct igt_drm_clients *clients,
+		   struct drm_client_fdinfo *info,
+		   unsigned int pid, char *name, unsigned int drm_minor)
 {
 	struct igt_drm_client *c;
 
-	assert(!igt_drm_clients_find(clients, IGT_DRM_CLIENT_ALIVE, id));
+	assert(!igt_drm_clients_find(clients, IGT_DRM_CLIENT_ALIVE, info->id));
 
 	c = igt_drm_clients_find(clients, IGT_DRM_CLIENT_FREE, 0);
 	if (!c) {
@@ -137,13 +138,14 @@ igt_drm_client_add(struct igt_drm_clients *clients, unsigned int id,
 		memset(c, 0, (clients->num_clients - idx) * sizeof(*c));
 	}
 
-	c->id = id;
+	c->id = info->id;
+	c->drm_minor = drm_minor;
 	c->clients = clients;
 	c->val = calloc(clients->num_classes, sizeof(c->val));
 	c->last = calloc(clients->num_classes, sizeof(c->last));
 	assert(c->val && c->last);
 
-	igt_drm_client_update(c, pid, name, busy);
+	igt_drm_client_update(c, pid, name, info->busy);
 }
 
 void igt_drm_client_free(struct igt_drm_client *c)
@@ -254,16 +256,21 @@ static bool get_task_name(const char *buffer, char *out, unsigned long sz)
 	return true;
 }
 
-static bool is_drm_fd(int fd_dir, const char *name)
+static bool is_drm_fd(int fd_dir, const char *name, unsigned int *minor)
 {
 	struct stat stat;
 	int ret;
 
 	ret = fstatat(fd_dir, name, &stat, 0);
 
-	return ret == 0 &&
-	       (stat.st_mode & S_IFMT) == S_IFCHR &&
-	       major(stat.st_rdev) == 226;
+	if (ret == 0 &&
+	    (stat.st_mode & S_IFMT) == S_IFCHR &&
+	    major(stat.st_rdev) == 226) {
+		*minor = minor(stat.st_rdev);
+		return true;
+	}
+
+	return false;
 }
 
 struct igt_drm_clients *
@@ -293,10 +300,10 @@ igt_drm_clients_scan(struct igt_drm_clients *clients,
 		return clients;
 
 	while ((proc_dent = readdir(proc_dir)) != NULL) {
+		unsigned int client_pid, minor = 0;
 		int pid_dir = -1, fd_dir = -1;
 		struct dirent *fdinfo_dent;
 		char client_name[64] = { };
-		unsigned int client_pid;
 		DIR *fdinfo_dir = NULL;
 		char buf[4096];
 		size_t count;
@@ -338,7 +345,7 @@ igt_drm_clients_scan(struct igt_drm_clients *clients,
 			if (!isdigit(fdinfo_dent->d_name[0]))
 				continue;
 
-			if (!is_drm_fd(fd_dir, fdinfo_dent->d_name))
+			if (!is_drm_fd(fd_dir, fdinfo_dent->d_name, &minor))
 				continue;
 
 			memset(&info, 0, sizeof(info));
@@ -358,8 +365,8 @@ igt_drm_clients_scan(struct igt_drm_clients *clients,
 			c = igt_drm_clients_find(clients, IGT_DRM_CLIENT_PROBE,
 						info.id);
 			if (!c)
-				igt_drm_client_add(clients, info.id, client_pid,
-						   client_name, info.busy);
+				igt_drm_client_add(clients, &info, client_pid,
+						   client_name, minor);
 			else
 				igt_drm_client_update(c, client_pid,
 						      client_name, info.busy);
lib/igt_drm_clients.h +4 -2
index 91e9da4c0733..7a6318c6af5f 100644
@@ -48,6 +48,7 @@ struct igt_drm_client {
 
 	enum igt_drm_client_status status;
 	unsigned int id;
+	unsigned int drm_minor;
 	unsigned int pid;
 	char name[24];
 	char print_name[24];
@@ -95,8 +96,9 @@ igt_drm_clients_sort(struct igt_drm_clients *clients,
 void igt_drm_client_update(struct igt_drm_client *c,
 			   unsigned int pid, char *name, uint64_t val[16]);
 
-void igt_drm_client_add(struct igt_drm_clients *clients, unsigned int id,
-			unsigned int pid, char *name, uint64_t busy[16]);
+void igt_drm_client_add(struct igt_drm_clients *clients,
+			struct drm_client_fdinfo *,
+			unsigned int pid, char *name, unsigned int drm_minor);
 
 void igt_drm_client_free(struct igt_drm_client *c);
 
Signature · 1 line
2.32.0
#13 lore raw

PATCH 7/11 libdrmclient: Support multiple DRM cards

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Require DRM minor match during client lookup.

---
 lib/igt_drm_clients.c | 14 ++++++++------
 lib/igt_drm_clients.h |  2 +-
 2 files changed, 9 insertions(+), 7 deletions(-)
lib/igt_drm_clients.c +8 -6
index 116479a9f363..cf044597d537 100644
@@ -57,7 +57,7 @@ struct igt_drm_clients *igt_drm_clients_init(void *private_data)
 struct igt_drm_client *
 igt_drm_clients_find(struct igt_drm_clients *clients,
 		     enum igt_drm_client_status status,
-		     unsigned int id)
+		     unsigned int drm_minor, unsigned int id)
 {
 	unsigned int start, num;
 	struct igt_drm_client *c;
@@ -69,7 +69,8 @@ igt_drm_clients_find(struct igt_drm_clients *clients,
 		if (status != c->status)
 			continue;
 
-		if (status == IGT_DRM_CLIENT_FREE || c->id == id)
+		if (status == IGT_DRM_CLIENT_FREE ||
+		    (drm_minor == c->drm_minor && c->id == id))
 			return c;
 	}
 
@@ -123,9 +124,10 @@ igt_drm_client_add(struct igt_drm_clients *clients,
 {
 	struct igt_drm_client *c;
 
-	assert(!igt_drm_clients_find(clients, IGT_DRM_CLIENT_ALIVE, info->id));
+	assert(!igt_drm_clients_find(clients, IGT_DRM_CLIENT_ALIVE,
+				     drm_minor, info->id));
 
-	c = igt_drm_clients_find(clients, IGT_DRM_CLIENT_FREE, 0);
+	c = igt_drm_clients_find(clients, IGT_DRM_CLIENT_FREE, 0, 0);
 	if (!c) {
 		unsigned int idx = clients->num_clients;
 
@@ -359,11 +361,11 @@ igt_drm_clients_scan(struct igt_drm_clients *clients,
 				continue;
 
 			if (igt_drm_clients_find(clients, IGT_DRM_CLIENT_ALIVE,
-						info.id))
+						 minor, info.id))
 				continue; /* Skip duplicate fds. */
 
 			c = igt_drm_clients_find(clients, IGT_DRM_CLIENT_PROBE,
-						info.id);
+						 minor, info.id);
 			if (!c)
 				igt_drm_client_add(clients, &info, client_pid,
 						   client_name, minor);
lib/igt_drm_clients.h +1 -1
index 7a6318c6af5f..6da445eab34a 100644
@@ -87,7 +87,7 @@ igt_drm_clients_scan(struct igt_drm_clients *clients,
 struct igt_drm_client *
 igt_drm_clients_find(struct igt_drm_clients *clients,
 		     enum igt_drm_client_status status,
-		     unsigned int id);
+		     unsigned int drm_minor, unsigned int id);
 
 struct igt_drm_clients *
 igt_drm_clients_sort(struct igt_drm_clients *clients,
Signature · 1 line
2.32.0
#14 lore raw

PATCH 8/11 libdrmfdinfo: Track largest engine index

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Prep code for incoming work.

---
 lib/igt_drm_fdinfo.c | 2 ++
 lib/igt_drm_fdinfo.h | 1 +
 2 files changed, 3 insertions(+)
lib/igt_drm_fdinfo.c +2 -0
index 96a8b768a4b1..964c6b708960 100644
@@ -159,6 +159,8 @@ __igt_parse_drm_fdinfo(int dir, const char *fd, struct drm_client_fdinfo *info,
 					info->capacity[idx] = 1;
 				info->busy[idx] = val;
 				info->num_engines++;
+				if (idx > info->last_engine_index)
+					info->last_engine_index = idx;
 			}
 		} else if (!strncmp(l, "drm-engine-capacity-", 20)) {
 			idx = parse_engine(l, info,
lib/igt_drm_fdinfo.h +1 -0
index bea4a6304734..804e8e1aa333 100644
@@ -36,6 +36,7 @@ struct drm_client_fdinfo {
 	unsigned long id;
 
 	unsigned int num_engines;
+	unsigned int last_engine_index;
 	unsigned int capacity[16];
 	char names[16][256];
 	uint64_t busy[16];
Signature · 1 line
2.32.0
#15 lore raw

PATCH 9/11 libdrmclient/intel_gpu_top: Decouple hardcoded engine assumptions

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Intel_gpu_top gets it's main engine configuration data via PMU probe and uses that for per client view as well. Furthemore code so far assumed only clients belonging from a single DRM card would be tracked in a single clients list.

Break this inter-dependency by moving the engine data to be per client and also have libdrmclient probe the engine configuration independently using the previously added libdrmfdinfo facilities.

---
 lib/igt_drm_clients.c |  34 +++++++++++--
 lib/igt_drm_clients.h |  11 ++---
 tools/intel_gpu_top.c | 112 ++++++++++++++++++++++++++++++------------
 3 files changed, 117 insertions(+), 40 deletions(-)
lib/igt_drm_clients.c +31 -3
index cf044597d537..6299f3632b74 100644
@@ -103,7 +103,7 @@ igt_drm_client_update(struct igt_drm_client *c, unsigned int pid, char *name,
 	c->last_runtime = 0;
 	c->total_runtime = 0;
 
-	for (i = 0; i < c->clients->num_classes; i++) {
+	for (i = 0; i <= c->engines->max_engine_id; i++) {
 		if (val[i] < c->last[i])
 			continue; /* It will catch up soon. */
 
@@ -123,6 +123,7 @@ igt_drm_client_add(struct igt_drm_clients *clients,
 		   unsigned int pid, char *name, unsigned int drm_minor)
 {
 	struct igt_drm_client *c;
+	unsigned int i;
 
 	assert(!igt_drm_clients_find(clients, IGT_DRM_CLIENT_ALIVE,
 				     drm_minor, info->id));
@@ -143,8 +144,28 @@ igt_drm_client_add(struct igt_drm_clients *clients,
 	c->id = info->id;
 	c->drm_minor = drm_minor;
 	c->clients = clients;
-	c->val = calloc(clients->num_classes, sizeof(c->val));
-	c->last = calloc(clients->num_classes, sizeof(c->last));
+	c->engines = malloc(sizeof(*c->engines));
+	assert(c->engines);
+	memset(c->engines, 0, sizeof(*c->engines));
+	c->engines->capacity = calloc(info->last_engine_index + 1,
+				      sizeof(*c->engines->capacity));
+	assert(c->engines->capacity);
+	c->engines->names = calloc(info->last_engine_index + 1,
+				   sizeof(*c->engines->names));
+	assert(c->engines->names);
+
+	for (i = 0; i <= info->last_engine_index; i++) {
+		if (!info->capacity[i])
+			continue;
+
+		c->engines->capacity[i] = info->capacity[i];
+		c->engines->names[i] = strdup(info->names[i]);
+		assert(c->engines->names[i]);
+		c->engines->num_engines++;
+		c->engines->max_engine_id = i;
+	}
+	c->val = calloc(c->engines->max_engine_id + 1, sizeof(c->val));
+	c->last = calloc(c->engines->max_engine_id + 1, sizeof(c->last));
 	assert(c->val && c->last);
 
 	igt_drm_client_update(c, pid, name, info->busy);
@@ -152,6 +173,13 @@ igt_drm_client_add(struct igt_drm_clients *clients,
 
 void igt_drm_client_free(struct igt_drm_client *c)
 {
+	unsigned int i;
+
+	for (i = 0; i <= c->engines->max_engine_id; i++)
+		free(c->engines->names[i]);
+	free(c->engines->capacity);
+	free(c->engines->names);
+	free(c->engines);
 	free(c->val);
 	free(c->last);
 	memset(c, 0, sizeof(*c));
lib/igt_drm_clients.h +5 -6
index 6da445eab34a..4668df2d7fd6 100644
@@ -35,10 +35,11 @@ enum igt_drm_client_status {
 	IGT_DRM_CLIENT_PROBE
 };
 
-struct igt_drm_client_engine_class {
-	unsigned int engine_class;
-	const char *name;
+struct igt_drm_client_engines {
 	unsigned int num_engines;
+	unsigned int max_engine_id;
+	unsigned int *capacity;
+	char **names;
 };
 
 struct igt_drm_clients;
@@ -47,6 +48,7 @@ struct igt_drm_client {
 	struct igt_drm_clients *clients;
 
 	enum igt_drm_client_status status;
+	struct igt_drm_client_engines *engines;
 	unsigned int id;
 	unsigned int drm_minor;
 	unsigned int pid;
@@ -63,9 +65,6 @@ struct igt_drm_clients {
 	unsigned int num_clients;
 	unsigned int active_clients;
 
-	unsigned int num_classes;
-	struct igt_drm_client_engine_class *engine_class;
-
 	void *private_data;
 
 	struct igt_drm_client *client; /* Must be last. */
tools/intel_gpu_top.c +81 -31

258 lines not on this page · raw message

Signature · 1 line
2.32.0
#16 lore raw

PATCH 10/11 libdrmclient: Enforce client status sort order in the library

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Some libdrmclient operations require that inactive clients are last in the list. Rather than relying on callers of the library sort routine to implement their comparison callbacks correctly, enforce this order directly in the library and let callers comparison callbacks concern themselves only with ordering they are interested in.

---
 lib/igt_drm_clients.c | 25 +++++++++++--
 lib/igt_drm_clients.h |  2 +-
 tools/intel_gpu_top.c | 81 +++++++++++++++++++------------------------
 3 files changed, 58 insertions(+), 50 deletions(-)
lib/igt_drm_clients.c +22 -3
index 6299f3632b74..e8e86969f984 100644
@@ -185,10 +185,29 @@ void igt_drm_client_free(struct igt_drm_client *c)
 	memset(c, 0, sizeof(*c));
 }
 
+struct sort_context
+{
+	int (*user_cmp)(const void *, const void *, void *);
+};
+
+static int sort_cmp(const void *_a, const void *_b, void *_ctx)
+{
+	const struct sort_context *ctx = _ctx;
+	const struct igt_drm_client *a = _a;
+	const struct igt_drm_client *b = _b;
+	int cmp = b->status - a->status;
+
+	if (cmp == 0)
+		return ctx->user_cmp(_a, _b, _ctx);
+	else
+		return cmp;
+}
+
 struct igt_drm_clients *
 igt_drm_clients_sort(struct igt_drm_clients *clients,
-		     int (*cmp)(const void *, const void *))
+		     int (*cmp)(const void *, const void *, void *))
 {
+	struct sort_context ctx = { .user_cmp = cmp };
 	unsigned int active, free;
 	struct igt_drm_client *c;
 	int tmp;
@@ -196,8 +215,8 @@ igt_drm_clients_sort(struct igt_drm_clients *clients,
 	if (!clients)
 		return clients;
 
-	qsort(clients->client, clients->num_clients, sizeof(*clients->client),
-	      cmp);
+	qsort_r(clients->client, clients->num_clients, sizeof(*clients->client),
+	      sort_cmp, &ctx);
 
 	/* Trim excessive array space. */
 	active = 0;
lib/igt_drm_clients.h +1 -1
index 4668df2d7fd6..47547aa8b75f 100644
@@ -90,7 +90,7 @@ igt_drm_clients_find(struct igt_drm_clients *clients,
 
 struct igt_drm_clients *
 igt_drm_clients_sort(struct igt_drm_clients *clients,
-		     int (*cmp)(const void *, const void *));
+		     int (*cmp)(const void *, const void *, void *));
 
 void igt_drm_client_update(struct igt_drm_client *c,
 			   unsigned int pid, char *name, uint64_t val[16]);
tools/intel_gpu_top.c +35 -46

127 lines not on this page · raw message

Signature · 1 line
2.32.0
#17 lore raw

PATCH 11/11 gputop: Basic vendor agnostic GPU top tool

In reply to Tvrtko Ursulin

From: Tvrtko Ursulin <[email protected]>

Rudimentary vendor agnostic example of how lib_igt_drm_clients can be used to display a sorted by card and usage list of processes using GPUs.

---
 tools/gputop.c    | 276 ++++++++++++++++++++++++++++++++++++++++++++++
 tools/meson.build |   5 +
 2 files changed, 281 insertions(+)
 create mode 100644 tools/gputop.c
tools/gputop.c new file +276 -0
new file mode 100644
index 000000000000..dbc5b7b4ce42
@@ -0,0 +1,276 @@
+/*
+ * Copyright © 2022 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ */
+
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.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 <sys/sysmacros.h>
+#include <stdbool.h>
+
+#include "igt_drm_clients.h"
+#include "igt_drm_fdinfo.h"
+
+#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
+
+static const char *bars[] = { " ", "▏", "▎", "▍", "▌", "▋", "▊", "▉", "█" };
+
+static void n_spaces(const unsigned int n)
+{
+	unsigned int i;
+
+	for (i = 0; i < n; i++)
+		putchar(' ');
+}
+
+static void print_percentage_bar(double percent, int max_len)
+{
+	int bar_len, i, len = max_len - 2;
+	const int w = 8;
+
+	assert(max_len > 0);
+
+	bar_len = ceil(w * percent * len / 100.0);
+	if (bar_len > w * len)
+		bar_len = w * len;
+
+	putchar('|');
+
+	for (i = bar_len; i >= w; i -= w)
+		printf("%s", bars[w]);
+	if (i)
+		printf("%s", bars[i]);
+
+	len -= (bar_len + (w - 1)) / w;
+	n_spaces(len);
+
+	putchar('|');
+}
+
+static int
+print_client_header(struct igt_drm_client *c, int lines, int con_w, int con_h,
+		    int *engine_w)
+{
+	const char *pidname = "   PID              NAME ";
+	int ret, len = strlen(pidname);
+
+	if (lines++ >= con_h || len >= con_w)
+		return lines;
+	printf("\033[7m");
+	ret = printf("DRM minor %u", c->drm_minor);
+	n_spaces(con_w - ret);
+
+	if (lines++ >= con_h)
+		return lines;
+	printf("\n%s", pidname);
+
+	if (c->engines->num_engines) {
+		unsigned int i;
+		int width;
+
+		*engine_w = width = (con_w - len) / c->engines->num_engines;
+
+		for (i = 0; i <= c->engines->max_engine_id; i++) {
+			const char *name = c->engines->names[i];
+			int name_len = strlen(name);
+			int pad = (width - name_len) / 2;
+			int spaces = width - pad - name_len;
+
+			if (!name)
+				continue;
+
+			if (pad < 0 || spaces < 0)
+				continue;
+
+			n_spaces(pad);
+			printf("%s", name);
+			n_spaces(spaces);
+			len += pad + name_len + spaces;
+		}
+	}
+
+	n_spaces(con_w - len);
+	printf("\033[0m\n");
+
+	return lines;
+}
+
+
+static bool
+newheader(const struct igt_drm_client *c, const struct igt_drm_client *pc)
+{
+	return !pc || c->drm_minor != pc->drm_minor;
+}
+
+static bool filter_idle = true;
+
+static int
+print_client(struct igt_drm_client *c, struct igt_drm_client **prevc,
+	     double t, int lines, int con_w, int con_h,
+	     unsigned int period_us, int *engine_w)
+{
+	unsigned int i;
+
+	if (filter_idle && (!c->total_runtime || c->samples < 2))
+		return lines;
+
+	if (newheader(c, *prevc)) {
+		lines = print_client_header(c, lines, con_w, con_h, engine_w);
+		if (lines >= con_h)
+			return lines;
+	}
+
+	*prevc = c;
+
+	printf("%6u %17s ", c->pid, c->print_name);
+	lines++;
+
+	for (i = 0; c->samples > 1 && i <= c->engines->max_engine_id; i++) {
+		double pct;
+
+		if (!c->engines->capacity[i])
+			continue;
+
+		pct = (double)c->val[i] / period_us / 1e3 * 100 /
+		      c->engines->capacity[i];
+
+		/*
+		 * Guard against possible time-drift between sampling
+		 * client data and time we obtained our time-delta from
+		 * PMU.
+		 */
+		if (pct > 100.0)
+			pct = 100.0;
+
+		print_percentage_bar(pct, *engine_w);
+	}
+
+	putchar('\n');
+
+	return lines;
+}
+
+static int
+__client_id_cmp(const struct igt_drm_client *a,
+		const struct igt_drm_client *b)
+{
+	if (a->id > b->id)
+		return 1;
+	else if (a->id < b->id)
+		return -1;
+	else
+		return 0;
+}
+
+static int client_cmp(const void *_a, const void *_b, void *unused)
+{
+	const struct igt_drm_client *a = _a;
+	const struct igt_drm_client *b = _b;
+	long val_a, val_b;
+
+	val_a = a->drm_minor;
+	val_b = b->drm_minor;
+	if (val_a > val_b)
+		return 1;
+	else if (val_b > val_a)
+		return -1;
+
+	val_a = a->last_runtime;
+	val_b = b->last_runtime;
+	if (val_a == val_b)
+		return __client_id_cmp(a, b);
+	else if (val_b > val_a)
+		return 1;
+	else
+		return -1;
+
+}
+
+int main(int argc, char **argv)
+{
+	unsigned int period_us = 2e6;
+	struct igt_drm_clients *clients = NULL;
+	int con_w = -1, con_h = -1;
+
+	clients = igt_drm_clients_init(NULL);
+	if (!clients)
+		exit(1);
+
+	igt_drm_clients_scan(clients, NULL, NULL, 0);
+
+	for (;;) {
+		struct igt_drm_client *c, *prevc = NULL;
+		int i, engine_w = 0, lines = 0;
+		struct winsize ws;
+
+		if (ioctl(0, TIOCGWINSZ, &ws) != -1) {
+			con_w = ws.ws_col;
+			con_h = ws.ws_row;
+			if (con_w == 0 && con_h == 0) {
+				/* Serial console. */
+				con_w = 80;
+				con_h = 24;
+			}
+		}
+
+		igt_drm_clients_scan(clients, NULL, NULL, 0);
+		igt_drm_clients_sort(clients, client_cmp);
+
+		printf("\033[H\033[J");
+
+		igt_for_each_drm_client(clients, c, i) {
+			assert(c->status != IGT_DRM_CLIENT_PROBE);
+			if (c->status != IGT_DRM_CLIENT_ALIVE)
+				break; /* Active clients are first in the array. */
+
+			lines = print_client(c, &prevc, (double)period_us / 1e6,
+					     lines, con_w, con_h, period_us,
+					     &engine_w);
+			if (lines >= con_h)
+				break;
+		}
+
+		if (lines++ < con_h)
+			printf("\n");
+
+		usleep(period_us);
+	}
+
+	return 0;
+}
tools/meson.build +5 -0
index e65aceeef9fa..508964004bb0 100644
@@ -69,6 +69,11 @@ if libudev.found()
 		   install : true)
 endif
 
+executable('gputop', 'gputop.c',
+           install : true,
+           install_rpath : bindir_rpathdir,
+           dependencies : [lib_igt_drm_clients,lib_igt_drm_fdinfo,math])
+
 intel_l3_parity_src = [ 'intel_l3_parity.c', 'intel_l3_udev_listener.c' ]
 executable('intel_l3_parity', sources : intel_l3_parity_src,
 	   dependencies : tool_deps,
Signature · 1 line
2.32.0
#18 lore raw

[igt-dev] ✓ Fi.CI.BAT: success for Per client GPU utilisation

In reply to Tvrtko Ursulin
== Series Details ==

== Series Details ==

Series: Per client GPU utilisation
URL : https://patchwork.freedesktop.org/series/100571/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_11266 -> IGTPW_6676
====================================================

Summary
-------

**SUCCESS**

No regressions found.

External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/index.html

Participating hosts (45 -> 43)
------------------------------

Additional (1): fi-pnv-d510
Missing (3): fi-ctg-p8600 fi-bsw-cyan fi-hsw-4200u

Known issues
------------

Here are the changes found in IGTPW_6676 that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@gem_flink_basic@bad-flink:
- fi-skl-6600u: [PASS][1] -> [FAIL][2] ([i915#4547])
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/fi-skl-6600u/igt@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/fi-skl-6600u/igt@[email protected]

* igt@i915_selftest@live@hangcheck:
- bat-dg1-6: [PASS][3] -> [DMESG-FAIL][4] ([i915#4494] / [i915#4957])
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/bat-dg1-6/igt@i915_selftest@[email protected]
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/bat-dg1-6/igt@i915_selftest@[email protected]

* igt@kms_frontbuffer_tracking@basic:
- fi-cml-u2: [PASS][5] -> [DMESG-WARN][6] ([i915#4269])
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/fi-cml-u2/igt@[email protected]
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/fi-cml-u2/igt@[email protected]

* igt@prime_vgem@basic-userptr:
- fi-pnv-d510: NOTRUN -> [SKIP][7] ([fdo#109271]) +57 similar issues
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/fi-pnv-d510/igt@[email protected]

* igt@runner@aborted:
- fi-bdw-5557u: NOTRUN -> [FAIL][8] ([i915#2426] / [i915#4312])
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/fi-bdw-5557u/igt@[email protected]

#### Possible fixes ####

* igt@i915_module_load@reload:
- fi-bsw-kefka: [DMESG-WARN][9] ([i915#1982]) -> [PASS][10]
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/fi-bsw-kefka/igt@[email protected]
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/fi-bsw-kefka/igt@[email protected]

* igt@kms_pipe_crc_basic@compare-crc-sanitycheck-pipe-b:
- fi-cfl-8109u: [DMESG-WARN][11] ([i915#295]) -> [PASS][12] +12 similar issues
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/fi-cfl-8109u/igt@[email protected]
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/fi-cfl-8109u/igt@[email protected]

#### Warnings ####

* igt@i915_selftest@live@hangcheck:
- bat-dg1-5: [DMESG-FAIL][13] ([i915#4494] / [i915#4957]) -> [DMESG-FAIL][14] ([i915#4957])
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/bat-dg1-5/igt@i915_selftest@[email protected]
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/bat-dg1-5/igt@i915_selftest@[email protected]

[fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
[i915#1982]: https://gitlab.freedesktop.org/drm/intel/issues/1982
[i915#2426]: https://gitlab.freedesktop.org/drm/intel/issues/2426
[i915#295]: https://gitlab.freedesktop.org/drm/intel/issues/295
[i915#4269]: https://gitlab.freedesktop.org/drm/intel/issues/4269
[i915#4312]: https://gitlab.freedesktop.org/drm/intel/issues/4312
[i915#4494]: https://gitlab.freedesktop.org/drm/intel/issues/4494
[i915#4547]: https://gitlab.freedesktop.org/drm/intel/issues/4547
[i915#4957]: https://gitlab.freedesktop.org/drm/intel/issues/4957

Build changes
-------------

* CI: CI-20190529 -> None
* IGT: IGT_6351 -> IGTPW_6676

CI-20190529: 20190529
CI_DRM_11266: 62ca4a90fa28434483476be736d67371671169e4 @ git://anongit.freedesktop.org/gfx-ci/linux
IGTPW_6676: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/index.html
IGT_6351: 5f3cfa485eb46902e55c6b96c80dc8c57ddf3b43 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git

== Testlist changes ==

+igt@drm_fdinfo@all-busy-check-all
+igt@drm_fdinfo@all-busy-idle-check-all
+igt@drm_fdinfo@basics
+igt@drm_fdinfo@busy
+igt@drm_fdinfo@busy-check-all
+igt@drm_fdinfo@busy-hang
+igt@drm_fdinfo@busy-idle
+igt@drm_fdinfo@busy-idle-check-all
+igt@drm_fdinfo@idle
+igt@drm_fdinfo@isolation
+igt@drm_fdinfo@most-busy-check-all
+igt@drm_fdinfo@most-busy-idle-check-all

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/index.html

#19 lore raw

[igt-dev] ✓ Fi.CI.IGT: success for Per client GPU utilisation

In reply to Tvrtko Ursulin
== Series Details ==

== Series Details ==

Series: Per client GPU utilisation
URL : https://patchwork.freedesktop.org/series/100571/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_11266_full -> IGTPW_6676_full
====================================================

Summary
-------

**SUCCESS**

No regressions found.

External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/index.html

Participating hosts (13 -> 8)
------------------------------

Missing (5): pig-kbl-iris pig-glk-j5005 pig-skl-6260u shard-rkl shard-dg1

Possible new issues
-------------------

Here are the unknown changes that may have been introduced in IGTPW_6676_full:

### IGT changes ###

#### Possible regressions ####

* {igt@drm_fdinfo@busy-check-all@bcs0} (NEW):
- shard-glk: NOTRUN -> [FAIL][1] +34 similar issues
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk3/igt@drm_fdinfo@[email protected]

* {igt@drm_fdinfo@busy@bcs0} (NEW):
- shard-apl: NOTRUN -> [FAIL][2] +33 similar issues
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl3/igt@drm_fdinfo@[email protected]

* {igt@drm_fdinfo@busy@vcs0} (NEW):
- shard-snb: NOTRUN -> [FAIL][3] +26 similar issues
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-snb4/igt@drm_fdinfo@[email protected]

* {igt@drm_fdinfo@isolation@bcs0} (NEW):
- shard-kbl: NOTRUN -> [FAIL][4] +20 similar issues
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl4/igt@drm_fdinfo@[email protected]
- {shard-tglu}: NOTRUN -> [FAIL][5] +19 similar issues
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglu-2/igt@drm_fdinfo@[email protected]
- shard-tglb: NOTRUN -> [FAIL][6] +20 similar issues
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb7/igt@drm_fdinfo@[email protected]

* {igt@drm_fdinfo@most-busy-check-all@vecs0} (NEW):
- shard-iclb: NOTRUN -> [FAIL][7] +28 similar issues
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb7/igt@drm_fdinfo@[email protected]

New tests
---------

New tests have been introduced between CI_DRM_11266_full and IGTPW_6676_full:

### New IGT tests (49) ###

* igt@drm_fdinfo@all-busy-check-all:
- Statuses : 6 fail(s)
- Exec time: [0.02, 0.16] s

* igt@drm_fdinfo@all-busy-idle-check-all:
- Statuses : 3 fail(s)
- Exec time: [0.08, 0.13] s

* igt@drm_fdinfo@basics:
- Statuses : 4 fail(s)
- Exec time: [0.01, 0.03] s

* igt@drm_fdinfo@busy:
- Statuses :
- Exec time: [None] s

* igt@drm_fdinfo@busy-check-all:
- Statuses :
- Exec time: [None] s

* igt@drm_fdinfo@busy-check-all@bcs0:
- Statuses : 7 fail(s)
- Exec time: [0.01, 0.04] s

* igt@drm_fdinfo@busy-check-all@rcs0:
- Statuses : 7 fail(s)
- Exec time: [0.03, 0.24] s

* igt@drm_fdinfo@busy-check-all@vcs0:
- Statuses : 7 fail(s)
- Exec time: [0.01, 0.51] s

* igt@drm_fdinfo@busy-check-all@vcs1:
- Statuses : 3 fail(s)
- Exec time: [0.01] s

* igt@drm_fdinfo@busy-check-all@vecs0:
- Statuses : 6 fail(s)
- Exec time: [0.01, 0.04] s

* igt@drm_fdinfo@busy-hang:
- Statuses :
- Exec time: [None] s

* igt@drm_fdinfo@busy-idle:
- Statuses :
- Exec time: [None] s

* igt@drm_fdinfo@busy-idle-check-all:
- Statuses :
- Exec time: [None] s

* igt@drm_fdinfo@busy-idle-check-all@bcs0:
- Statuses : 4 fail(s)
- Exec time: [0.01, 0.04] s

* igt@drm_fdinfo@busy-idle-check-all@rcs0:
- Statuses : 4 fail(s)
- Exec time: [0.02, 0.13] s

* igt@drm_fdinfo@busy-idle-check-all@vcs0:
- Statuses : 4 fail(s)
- Exec time: [0.01, 0.51] s

* igt@drm_fdinfo@busy-idle-check-all@vcs1:
- Statuses : 1 fail(s)
- Exec time: [0.01] s

* igt@drm_fdinfo@busy-idle-check-all@vecs0:
- Statuses : 3 fail(s)
- Exec time: [0.01, 0.04] s

* igt@drm_fdinfo@busy-idle@bcs0:
- Statuses : 7 fail(s)
- Exec time: [0.01, 0.04] s

* igt@drm_fdinfo@busy-idle@rcs0:
- Statuses : 7 fail(s)
- Exec time: [0.01, 0.05] s

* igt@drm_fdinfo@busy-idle@vcs0:
- Statuses : 7 fail(s)
- Exec time: [0.01, 0.51] s

* igt@drm_fdinfo@busy-idle@vcs1:
- Statuses : 4 fail(s)
- Exec time: [0.01] s

* igt@drm_fdinfo@busy-idle@vecs0:
- Statuses : 6 fail(s)
- Exec time: [0.01, 0.03] s

* igt@drm_fdinfo@busy@bcs0:
- Statuses : 3 fail(s)
- Exec time: [0.01, 0.04] s

* igt@drm_fdinfo@busy@rcs0:
- Statuses : 3 fail(s)
- Exec time: [0.01, 0.05] s

* igt@drm_fdinfo@busy@vcs0:
- Statuses : 3 fail(s)
- Exec time: [0.03, 0.51] s

* igt@drm_fdinfo@busy@vecs0:
- Statuses : 2 fail(s)
- Exec time: [0.04] s

* igt@drm_fdinfo@idle:
- Statuses :
- Exec time: [None] s

* igt@drm_fdinfo@idle@bcs0:
- Statuses : 3 fail(s)
- Exec time: [0.01, 0.03] s

* igt@drm_fdinfo@idle@rcs0:
- Statuses : 3 fail(s)
- Exec time: [0.12, 0.24] s

* igt@drm_fdinfo@idle@vcs0:
- Statuses : 3 fail(s)
- Exec time: [0.01, 0.02] s

* igt@drm_fdinfo@idle@vecs0:
- Statuses : 2 fail(s)
- Exec time: [0.02] s

* igt@drm_fdinfo@isolation:
- Statuses :
- Exec time: [None] s

* igt@drm_fdinfo@isolation@bcs0:
- Statuses : 7 fail(s)
- Exec time: [0.01, 0.04] s

* igt@drm_fdinfo@isolation@rcs0:
- Statuses : 7 fail(s)
- Exec time: [0.03, 0.16] s

* igt@drm_fdinfo@isolation@vcs0:
- Statuses : 7 fail(s)
- Exec time: [0.01, 0.51] s

* igt@drm_fdinfo@isolation@vcs1:
- Statuses : 3 fail(s)
- Exec time: [0.01] s

* igt@drm_fdinfo@isolation@vecs0:
- Statuses : 6 fail(s)
- Exec time: [0.01, 0.04] s

* igt@drm_fdinfo@most-busy-check-all:
- Statuses :
- Exec time: [None] s

* igt@drm_fdinfo@most-busy-check-all@bcs0:
- Statuses : 4 fail(s)
- Exec time: [0.01, 0.03] s

* igt@drm_fdinfo@most-busy-check-all@rcs0:
- Statuses : 4 fail(s)
- Exec time: [0.04, 0.12] s

* igt@drm_fdinfo@most-busy-check-all@vcs0:
- Statuses : 4 fail(s)
- Exec time: [0.01, 0.03] s

* igt@drm_fdinfo@most-busy-check-all@vecs0:
- Statuses : 3 fail(s)
- Exec time: [0.01, 0.03] s

* igt@drm_fdinfo@most-busy-idle-check-all:
- Statuses :
- Exec time: [None] s

* igt@drm_fdinfo@most-busy-idle-check-all@bcs0:
- Statuses : 7 fail(s)
- Exec time: [0.01, 0.04] s

* igt@drm_fdinfo@most-busy-idle-check-all@rcs0:
- Statuses : 7 fail(s)
- Exec time: [0.03, 0.13] s

* igt@drm_fdinfo@most-busy-idle-check-all@vcs0:
- Statuses : 7 fail(s)
- Exec time: [0.01, 0.03] s

* igt@drm_fdinfo@most-busy-idle-check-all@vcs1:
- Statuses : 3 fail(s)
- Exec time: [0.01] s

* igt@drm_fdinfo@most-busy-idle-check-all@vecs0:
- Statuses : 6 fail(s)
- Exec time: [0.01, 0.03] s

Known issues
------------

Here are the changes found in IGTPW_6676_full that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@gem_create@create-massive:
- shard-kbl: NOTRUN -> [DMESG-WARN][8] ([i915#4991])
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl7/igt@[email protected]
- shard-tglb: NOTRUN -> [DMESG-WARN][9] ([i915#4991])
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb7/igt@[email protected]

* igt@gem_ctx_persistence@legacy-engines-queued:
- shard-snb: NOTRUN -> [SKIP][10] ([fdo#109271] / [i915#1099]) +1 similar issue
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-snb2/igt@[email protected]

* igt@gem_ctx_sseu@invalid-sseu:
- shard-tglb: NOTRUN -> [SKIP][11] ([i915#280]) +1 similar issue
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb5/igt@[email protected]

* igt@gem_exec_balancer@parallel-keep-in-fence:
- shard-kbl: NOTRUN -> [DMESG-WARN][12] ([i915#5076]) +1 similar issue
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl3/igt@[email protected]

* igt@gem_exec_capture@pi@vecs0:
- shard-iclb: NOTRUN -> [INCOMPLETE][13] ([i915#3371])
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb3/igt@gem_exec_capture@[email protected]

* igt@gem_exec_fair@basic-none-rrul@rcs0:
- shard-tglb: NOTRUN -> [FAIL][14] ([i915#2842]) +2 similar issues
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb7/igt@gem_exec_fair@[email protected]

* igt@gem_exec_fair@basic-none-share@rcs0:
- shard-iclb: [PASS][15] -> [FAIL][16] ([i915#2842])
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-iclb7/igt@gem_exec_fair@[email protected]
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb4/igt@gem_exec_fair@[email protected]

* igt@gem_exec_fair@basic-none-solo@rcs0:
- shard-kbl: [PASS][17] -> [FAIL][18] ([i915#2842])
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-kbl7/igt@gem_exec_fair@[email protected]
[18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl4/igt@gem_exec_fair@[email protected]

* igt@gem_exec_fair@basic-pace@vecs0:
- shard-tglb: [PASS][19] -> [FAIL][20] ([i915#2842]) +1 similar issue
[19]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-tglb1/igt@gem_exec_fair@[email protected]
[20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb6/igt@gem_exec_fair@[email protected]

* igt@gem_exec_params@secure-non-root:
- shard-tglb: NOTRUN -> [SKIP][21] ([fdo#112283]) +1 similar issue
[21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb5/igt@[email protected]
- shard-iclb: NOTRUN -> [SKIP][22] ([fdo#112283]) +1 similar issue
[22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb5/igt@[email protected]

* igt@gem_lmem_swapping@parallel-random:
- shard-kbl: NOTRUN -> [SKIP][23] ([fdo#109271] / [i915#4613]) +2 similar issues
[23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl1/igt@[email protected]

* igt@gem_lmem_swapping@random:
- shard-tglb: NOTRUN -> [SKIP][24] ([i915#4613]) +4 similar issues
[24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb3/igt@[email protected]

* igt@gem_lmem_swapping@verify:
- shard-iclb: NOTRUN -> [SKIP][25] ([i915#4613]) +1 similar issue
[25]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb3/igt@[email protected]
- shard-apl: NOTRUN -> [SKIP][26] ([fdo#109271] / [i915#4613])
[26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl2/igt@[email protected]

* igt@gem_partial_pwrite_pread@write-display:
- shard-glk: [PASS][27] -> [DMESG-WARN][28] ([i915#118]) +3 similar issues
[27]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-glk9/igt@[email protected]
[28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk5/igt@[email protected]

* igt@gem_pxp@create-protected-buffer:
- shard-iclb: NOTRUN -> [SKIP][29] ([i915#4270]) +2 similar issues
[29]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb5/igt@[email protected]

* igt@gem_pxp@regular-baseline-src-copy-readible:
- shard-tglb: NOTRUN -> [SKIP][30] ([i915#4270]) +4 similar issues
[30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb2/igt@[email protected]

* igt@gem_render_copy@y-tiled-ccs-to-y-tiled-mc-ccs:
- shard-iclb: NOTRUN -> [SKIP][31] ([i915#768]) +3 similar issues
[31]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb2/igt@[email protected]

* igt@gem_userptr_blits@input-checking:
- shard-apl: NOTRUN -> [DMESG-WARN][32] ([i915#4991])
[32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl7/igt@[email protected]
- shard-glk: NOTRUN -> [DMESG-WARN][33] ([i915#4991])
[33]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk1/igt@[email protected]
- shard-snb: NOTRUN -> [DMESG-WARN][34] ([i915#4991])
[34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-snb7/igt@[email protected]

* igt@gem_userptr_blits@unsync-unmap-cycles:
- shard-tglb: NOTRUN -> [SKIP][35] ([i915#3297])
[35]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb3/igt@[email protected]

* igt@gem_userptr_blits@vma-merge:
- shard-snb: NOTRUN -> [FAIL][36] ([i915#2724])
[36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-snb5/igt@[email protected]
- shard-apl: NOTRUN -> [FAIL][37] ([i915#3318])
[37]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl1/igt@[email protected]
- shard-iclb: NOTRUN -> [FAIL][38] ([i915#3318])
[38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb1/igt@[email protected]
- shard-glk: NOTRUN -> [FAIL][39] ([i915#3318])
[39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk5/igt@[email protected]
- shard-kbl: NOTRUN -> [FAIL][40] ([i915#3318])
[40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl4/igt@[email protected]
- shard-tglb: NOTRUN -> [FAIL][41] ([i915#3318])
[41]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb6/igt@[email protected]

* igt@gen7_exec_parse@basic-allocation:
- shard-tglb: NOTRUN -> [SKIP][42] ([fdo#109289]) +5 similar issues
[42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb7/igt@[email protected]

* igt@gen9_exec_parse@allowed-all:
- shard-apl: [PASS][43] -> [DMESG-WARN][44] ([i915#1436] / [i915#716])
[43]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-apl8/igt@[email protected]
[44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl3/igt@[email protected]

* igt@gen9_exec_parse@batch-without-end:
- shard-iclb: NOTRUN -> [SKIP][45] ([i915#2856]) +2 similar issues
[45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb1/igt@[email protected]

* igt@gen9_exec_parse@bb-oversize:
- shard-tglb: NOTRUN -> [SKIP][46] ([i915#2527] / [i915#2856]) +3 similar issues
[46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb1/igt@[email protected]

* igt@i915_pm_dc@dc6-dpms:
- shard-kbl: NOTRUN -> [FAIL][47] ([i915#454])
[47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl4/igt@[email protected]

* igt@i915_pm_dc@dc9-dpms:
- shard-iclb: [PASS][48] -> [SKIP][49] ([i915#4281])
[48]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-iclb4/igt@[email protected]
[49]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb3/igt@[email protected]

* igt@i915_pm_lpsp@kms-lpsp@kms-lpsp-dp:
- shard-kbl: NOTRUN -> [SKIP][50] ([fdo#109271] / [i915#1937])
[50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl7/igt@i915_pm_lpsp@[email protected]
- shard-apl: NOTRUN -> [SKIP][51] ([fdo#109271] / [i915#1937])
[51]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl4/igt@i915_pm_lpsp@[email protected]

* igt@i915_pm_rc6_residency@rc6-fence:
- shard-tglb: NOTRUN -> [WARN][52] ([i915#2681] / [i915#2684])
[52]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb1/igt@[email protected]

* igt@i915_pm_rpm@dpms-non-lpsp:
- shard-tglb: NOTRUN -> [SKIP][53] ([fdo#111644] / [i915#1397] / [i915#2411])
[53]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb6/igt@[email protected]

* igt@i915_pm_rpm@modeset-pc8-residency-stress:
- shard-tglb: NOTRUN -> [SKIP][54] ([fdo#109506] / [i915#2411])
[54]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb2/igt@[email protected]

* igt@i915_pm_rpm@system-suspend-execbuf:
- shard-iclb: [PASS][55] -> [INCOMPLETE][56] ([i915#5096])
[55]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-iclb2/igt@[email protected]
[56]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb4/igt@[email protected]

* igt@i915_pm_sseu@full-enable:
- shard-tglb: NOTRUN -> [SKIP][57] ([i915#4387])
[57]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb3/igt@[email protected]

* igt@i915_query@query-topology-unsupported:
- shard-tglb: NOTRUN -> [SKIP][58] ([fdo#109302])
[58]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb7/igt@[email protected]

* igt@i915_selftest@live@gt_lrc:
- shard-tglb: NOTRUN -> [DMESG-FAIL][59] ([i915#2373])
[59]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb5/igt@i915_selftest@live@gt_lrc.html

* igt@i915_selftest@live@gt_pm:
- shard-tglb: NOTRUN -> [DMESG-FAIL][60] ([i915#1759])
[60]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb5/igt@i915_selftest@live@gt_pm.html

* igt@i915_selftest@live@hangcheck:
- shard-snb: [PASS][61] -> [INCOMPLETE][62] ([i915#3921])
[61]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-snb5/igt@i915_selftest@[email protected]
[62]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-snb7/igt@i915_selftest@[email protected]

* igt@i915_selftest@mock@hugepages:
- shard-apl: NOTRUN -> [INCOMPLETE][63] ([i915#5123])
[63]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl8/igt@i915_selftest@[email protected]
- shard-kbl: NOTRUN -> [INCOMPLETE][64] ([i915#5123])
[64]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl6/igt@i915_selftest@[email protected]

* igt@kms_atomic@atomic_plane_damage:
- shard-iclb: NOTRUN -> [SKIP][65] ([i915#4765])
[65]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb6/igt@kms_atomic@atomic_plane_damage.html

* igt@kms_atomic_transition@plane-all-modeset-transition-fencing:
- shard-iclb: NOTRUN -> [SKIP][66] ([i915#1769])
[66]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb6/igt@[email protected]
- shard-tglb: NOTRUN -> [SKIP][67] ([i915#1769])
[67]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb3/igt@[email protected]

* igt@kms_big_fb@x-tiled-32bpp-rotate-180:
- shard-glk: NOTRUN -> [DMESG-WARN][68] ([i915#118])
[68]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk1/igt@[email protected]

* igt@kms_big_fb@x-tiled-32bpp-rotate-90:
- shard-tglb: NOTRUN -> [SKIP][69] ([fdo#111614]) +1 similar issue
[69]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb6/igt@[email protected]
- shard-iclb: NOTRUN -> [SKIP][70] ([fdo#110725] / [fdo#111614]) +1 similar issue
[70]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb3/igt@[email protected]

* igt@kms_big_fb@y-tiled-max-hw-stride-64bpp-rotate-0-hflip:
- shard-kbl: NOTRUN -> [SKIP][71] ([fdo#109271] / [i915#3777]) +1 similar issue
[71]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl1/igt@[email protected]

* igt@kms_big_fb@yf-tiled-8bpp-rotate-180:
- shard-tglb: NOTRUN -> [SKIP][72] ([fdo#111615]) +8 similar issues
[72]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb1/igt@[email protected]

* igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip:
- shard-apl: NOTRUN -> [SKIP][73] ([fdo#109271] / [i915#3777]) +4 similar issues
[73]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl7/igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip.html
- shard-glk: NOTRUN -> [SKIP][74] ([fdo#109271] / [i915#3777]) +2 similar issues
[74]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk1/igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip.html

* igt@kms_big_fb@yf-tiled-max-hw-stride-64bpp-rotate-180-async-flip:
- shard-iclb: NOTRUN -> [SKIP][75] ([fdo#110723]) +4 similar issues
[75]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb4/igt@kms_big_fb@yf-tiled-max-hw-stride-64bpp-rotate-180-async-flip.html

* igt@kms_big_joiner@basic:
- shard-tglb: NOTRUN -> [SKIP][76] ([i915#2705])
[76]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb5/igt@[email protected]

* igt@kms_ccs@pipe-a-crc-sprite-planes-basic-y_tiled_ccs:
- shard-tglb: NOTRUN -> [SKIP][77] ([i915#3689]) +10 similar issues
[77]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb7/igt@kms_ccs@pipe-a-crc-sprite-planes-basic-y_tiled_ccs.html

* igt@kms_ccs@pipe-a-random-ccs-data-y_tiled_gen12_mc_ccs:
- shard-kbl: NOTRUN -> [SKIP][78] ([fdo#109271] / [i915#3886]) +10 similar issues
[78]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl1/igt@kms_ccs@pipe-a-random-ccs-data-y_tiled_gen12_mc_ccs.html

* igt@kms_ccs@pipe-b-bad-rotation-90-y_tiled_gen12_mc_ccs:
- shard-tglb: NOTRUN -> [SKIP][79] ([i915#3689] / [i915#3886]) +6 similar issues
[79]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb3/igt@kms_ccs@pipe-b-bad-rotation-90-y_tiled_gen12_mc_ccs.html

* igt@kms_ccs@pipe-b-crc-sprite-planes-basic-y_tiled_gen12_rc_ccs_cc:
- shard-apl: NOTRUN -> [SKIP][80] ([fdo#109271] / [i915#3886]) +8 similar issues
[80]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl8/igt@kms_ccs@pipe-b-crc-sprite-planes-basic-y_tiled_gen12_rc_ccs_cc.html

* igt@kms_ccs@pipe-b-random-ccs-data-y_tiled_gen12_mc_ccs:
- shard-iclb: NOTRUN -> [SKIP][81] ([fdo#109278] / [i915#3886]) +6 similar issues
[81]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb3/igt@kms_ccs@pipe-b-random-ccs-data-y_tiled_gen12_mc_ccs.html

* igt@kms_ccs@pipe-c-ccs-on-another-bo-y_tiled_gen12_mc_ccs:
- shard-glk: NOTRUN -> [SKIP][82] ([fdo#109271] / [i915#3886]) +1 similar issue
[82]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk7/igt@kms_ccs@pipe-c-ccs-on-another-bo-y_tiled_gen12_mc_ccs.html

* igt@kms_ccs@pipe-c-random-ccs-data-yf_tiled_ccs:
- shard-tglb: NOTRUN -> [SKIP][83] ([fdo#111615] / [i915#3689]) +4 similar issues
[83]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb3/igt@kms_ccs@pipe-c-random-ccs-data-yf_tiled_ccs.html

* igt@kms_ccs@pipe-d-crc-primary-rotation-180-y_tiled_gen12_mc_ccs:
- shard-glk: NOTRUN -> [SKIP][84] ([fdo#109271]) +70 similar issues
[84]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk3/igt@kms_ccs@pipe-d-crc-primary-rotation-180-y_tiled_gen12_mc_ccs.html

* igt@kms_chamelium@common-hpd-after-suspend:
- shard-glk: NOTRUN -> [SKIP][85] ([fdo#109271] / [fdo#111827]) +6 similar issues
[85]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk6/igt@[email protected]

* igt@kms_chamelium@hdmi-edid-change-during-suspend:
- shard-apl: NOTRUN -> [SKIP][86] ([fdo#109271] / [fdo#111827]) +7 similar issues
[86]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-apl4/igt@[email protected]

* igt@kms_chamelium@hdmi-hpd-enable-disable-mode:
- shard-iclb: NOTRUN -> [SKIP][87] ([fdo#109284] / [fdo#111827]) +9 similar issues
[87]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb1/igt@[email protected]
- shard-snb: NOTRUN -> [SKIP][88] ([fdo#109271] / [fdo#111827]) +6 similar issues
[88]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-snb4/igt@[email protected]

* igt@kms_color@pipe-d-ctm-max:
- shard-iclb: NOTRUN -> [SKIP][89] ([fdo#109278] / [i915#1149])
[89]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb7/igt@[email protected]

* igt@kms_color_chamelium@pipe-b-ctm-0-25:
- shard-kbl: NOTRUN -> [SKIP][90] ([fdo#109271] / [fdo#111827]) +15 similar issues
[90]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl1/igt@[email protected]

* igt@kms_color_chamelium@pipe-b-ctm-0-75:
- shard-tglb: NOTRUN -> [SKIP][91] ([fdo#109284] / [fdo#111827]) +13 similar issues
[91]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb7/igt@[email protected]

* igt@kms_content_protection@atomic-dpms:
- shard-kbl: NOTRUN -> [TIMEOUT][92] ([i915#1319])
[92]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl3/igt@[email protected]

* igt@kms_content_protection@dp-mst-lic-type-1:
- shard-iclb: NOTRUN -> [SKIP][93] ([i915#3116])
[93]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb3/igt@[email protected]
- shard-tglb: NOTRUN -> [SKIP][94] ([i915#3116] / [i915#3299])
[94]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb6/igt@[email protected]

* igt@kms_cursor_crc@pipe-a-cursor-512x512-rapid-movement:
- shard-iclb: NOTRUN -> [SKIP][95] ([fdo#109278] / [fdo#109279]) +3 similar issues
[95]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb1/igt@[email protected]

* igt@kms_cursor_crc@pipe-b-cursor-32x32-offscreen:
- shard-tglb: NOTRUN -> [SKIP][96] ([i915#3319]) +5 similar issues
[96]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb1/igt@[email protected]

* igt@kms_cursor_crc@pipe-b-cursor-max-size-onscreen:
- shard-tglb: NOTRUN -> [SKIP][97] ([i915#3359]) +4 similar issues
[97]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb6/igt@[email protected]

* igt@kms_cursor_crc@pipe-d-cursor-256x256-onscreen:
- shard-kbl: NOTRUN -> [SKIP][98] ([fdo#109271]) +233 similar issues
[98]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl4/igt@[email protected]

* igt@kms_cursor_crc@pipe-d-cursor-512x170-random:
- shard-tglb: NOTRUN -> [SKIP][99] ([fdo#109279] / [i915#3359]) +9 similar issues
[99]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb7/igt@[email protected]

* igt@kms_cursor_legacy@2x-long-cursor-vs-flip-legacy:
- shard-tglb: NOTRUN -> [SKIP][100] ([fdo#109274] / [fdo#111825]) +14 similar issues
[100]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb2/igt@[email protected]

* igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions-varying-size:
- shard-iclb: NOTRUN -> [SKIP][101] ([fdo#109274] / [fdo#109278]) +3 similar issues
[101]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb2/igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions-varying-size.html

* igt@kms_dither@fb-8bpc-vs-panel-8bpc@edp-1-pipe-a:
- shard-tglb: NOTRUN -> [SKIP][102] ([i915#3788])
[102]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb5/igt@kms_dither@[email protected]

* igt@kms_dp_tiled_display@basic-test-pattern:
- shard-iclb: NOTRUN -> [SKIP][103] ([i915#426])
[103]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb5/igt@[email protected]
- shard-tglb: NOTRUN -> [SKIP][104] ([i915#426])
[104]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-tglb5/igt@[email protected]

* igt@kms_flip@2x-flip-vs-expired-vblank-interruptible@ac-hdmi-a1-hdmi-a2:
- shard-glk: [PASS][105] -> [FAIL][106] ([i915#79])
[105]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-glk4/igt@kms_flip@[email protected]
[106]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-glk8/igt@kms_flip@[email protected]

* igt@kms_flip@2x-flip-vs-rmfb-interruptible:
- shard-iclb: NOTRUN -> [SKIP][107] ([fdo#109274]) +4 similar issues
[107]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-iclb8/igt@[email protected]

* igt@kms_flip@flip-vs-suspend-interruptible@a-dp1:
- shard-kbl: NOTRUN -> [DMESG-WARN][108] ([i915#180]) +3 similar issues
[108]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/shard-kbl7/igt@kms_flip@[email protected]

* igt@kms_flip@flip-vs-suspend@c-dp1:
- shard-apl: [PASS][109] -> [DMESG-WARN][110] ([i915#180]) +1 similar issue
[109]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_11266/shard-apl3/igt@kms_flip@flip-vs-suspend@c-dp

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_6676/index.html