Re: [PATCH i-g-t 23/28] tools/xe-perf: xe_perf_reader, xe_perf_control and xe_perf_configs

[Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>]

On Thu, Jun 20, 2024 at 01:00:48PM -0700, Ashutosh Dixit wrote:
>Add xe_perf_reader, xe_perf_control and xe_perf_configs tools, similar to
>their i915 counterparts.
>
>Signed-off-by: Ashutosh Dixit <ashutosh.dixit@intel.com>
Reviewed-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>

>---
> tools/xe-perf/meson.build       |  17 ++
> tools/xe-perf/xe_perf_configs.c | 247 ++++++++++++++++++++++++
> tools/xe-perf/xe_perf_control.c | 117 ++++++++++++
> tools/xe-perf/xe_perf_reader.c  | 325 ++++++++++++++++++++++++++++++++
> 4 files changed, 706 insertions(+)
> create mode 100644 tools/xe-perf/xe_perf_configs.c
> create mode 100644 tools/xe-perf/xe_perf_control.c
> create mode 100644 tools/xe-perf/xe_perf_reader.c
>
>diff --git a/tools/xe-perf/meson.build b/tools/xe-perf/meson.build
>index a5f59a67fe..8506aa320f 100644
>--- a/tools/xe-perf/meson.build
>+++ b/tools/xe-perf/meson.build
>@@ -1,5 +1,22 @@
>+executable('xe-perf-configs',
>+           [ 'xe_perf_configs.c' ],
>+           include_directories: inc,
>+           dependencies: [lib_igt_chipset, lib_igt_xe_oa],
>+           install: true)
>+
> executable('xe-perf-recorder',
>            [ 'xe_perf_recorder.c' ],
>            include_directories: inc,
>            dependencies: [lib_igt, lib_igt_xe_oa],
>            install: true)
>+
>+executable('xe-perf-control',
>+           [ 'xe_perf_control.c' ],
>+           include_directories: inc,
>+           install: true)
>+
>+executable('xe-perf-reader',
>+           [ 'xe_perf_reader.c' ],
>+           include_directories: inc,
>+           dependencies: [lib_igt, lib_igt_xe_oa],
>+           install: true)
>diff --git a/tools/xe-perf/xe_perf_configs.c b/tools/xe-perf/xe_perf_configs.c
>new file mode 100644
>index 0000000000..af33c0078c
>--- /dev/null
>+++ b/tools/xe-perf/xe_perf_configs.c
>@@ -0,0 +1,247 @@
>+// SPDX-License-Identifier: MIT
>+/*
>+ * Copyright © 2024 Intel Corporation
>+ */
>+
>+
>+#include <assert.h>
>+#include <dirent.h>
>+#include <errno.h>
>+#include <fcntl.h>
>+#include <getopt.h>
>+#include <inttypes.h>
>+#include <stdbool.h>
>+#include <stdint.h>
>+#include <stdio.h>
>+#include <stdlib.h>
>+#include <string.h>
>+#include <sys/ioctl.h>
>+#include <sys/sysmacros.h>
>+#include <sys/types.h>
>+#include <sys/stat.h>
>+#include <unistd.h>
>+
>+#include "intel_chipset.h"
>+#include "xe/xe_oa.h"
>+
>+static bool
>+read_file_uint64(const char *file, uint64_t *value)
>+{
>+	char buf[32];
>+	int fd, n;
>+
>+	fd = open(file, 0);
>+	if (fd < 0)
>+		return false;
>+	n = read(fd, buf, sizeof (buf) - 1);
>+	close(fd);
>+	if (n < 0)
>+		return false;
>+
>+	buf[n] = '\0';
>+	*value = strtoull(buf, 0, 0);
>+
>+	return true;
>+}
>+
>+static uint32_t
>+read_device_param(const char *stem, int id, const char *param)
>+{
>+	char *name;
>+	int ret = asprintf(&name, "/sys/class/drm/%s%u/device/%s", stem, id, param);
>+	uint64_t value;
>+	bool success;
>+
>+	assert(ret != -1);
>+
>+	success = read_file_uint64(name, &value);
>+	free(name);
>+
>+	return success ? value : 0;
>+}
>+
>+static int
>+find_intel_render_node(void)
>+{
>+	for (int i = 128; i < (128 + 16); i++) {
>+		if (read_device_param("renderD", i, "vendor") == 0x8086)
>+			return i;
>+	}
>+
>+	return -1;
>+}
>+
>+static int
>+open_render_node(uint32_t *devid)
>+{
>+	char *name;
>+	int ret;
>+	int fd;
>+
>+	int render = find_intel_render_node();
>+	if (render < 0)
>+		return -1;
>+
>+	ret = asprintf(&name, "/dev/dri/renderD%u", render);
>+	assert(ret != -1);
>+
>+	*devid = read_device_param("renderD", render, "device");
>+
>+	fd = open(name, O_RDWR);
>+	free(name);
>+
>+	return fd;
>+}
>+
>+static int
>+get_card_for_fd(int fd)
>+{
>+	struct stat sb;
>+	int mjr, mnr;
>+	char buffer[128];
>+	DIR *drm_dir;
>+	struct dirent *entry;
>+	int retval = -1;
>+
>+	if (fstat(fd, &sb)) {
>+		fprintf(stderr, "Failed to stat DRM fd\n");
>+		return -1;
>+	}
>+
>+	mjr = major(sb.st_rdev);
>+	mnr = minor(sb.st_rdev);
>+
>+	snprintf(buffer, sizeof(buffer), "/sys/dev/char/%d:%d/device/drm", mjr, mnr);
>+
>+	drm_dir = opendir(buffer);
>+	assert(drm_dir != NULL);
>+
>+	while ((entry = readdir(drm_dir))) {
>+		if (entry->d_type == DT_DIR && strncmp(entry->d_name, "card", 4) == 0) {
>+			retval = strtoull(entry->d_name + 4, NULL, 10);
>+			break;
>+		}
>+	}
>+
>+	closedir(drm_dir);
>+
>+	return retval;
>+}
>+
>+static const char *
>+metric_name(struct intel_xe_perf *perf, const char *hw_config_guid)
>+{
>+	struct intel_xe_perf_metric_set *metric_set;
>+
>+	igt_list_for_each_entry(metric_set, &perf->metric_sets, link) {
>+		if (!strcmp(metric_set->hw_config_guid, hw_config_guid))
>+			return metric_set->symbol_name;
>+	}
>+
>+	return "Unknown";
>+}
>+
>+static void
>+usage(void)
>+{
>+	printf("Usage: xe-perf-configs [options]\n"
>+	       "Manages xe-perf configurations stored in xe.\n"
>+	       "     --purge, -p         Purge configurations from the kernel\n"
>+	       "     --list,  -l         List configurations from the kernel\n");
>+}
>+
>+int
>+main(int argc, char *argv[])
>+{
>+	char metrics_path[128];
>+	DIR *metrics_dir;
>+	struct dirent *entry;
>+	int drm_fd, drm_card;
>+	int opt;
>+	bool purge = false;
>+	const struct option long_options[] = {
>+		{"help",   no_argument, 0, 'h'},
>+		{"list",   no_argument, 0, 'l'},
>+		{"purge",  no_argument, 0, 'p'},
>+		{0, 0, 0, 0}
>+	};
>+	const struct intel_device_info *devinfo;
>+	struct intel_xe_perf *perf;
>+	uint32_t devid = 0;
>+
>+	while ((opt = getopt_long(argc, argv, "hlp", long_options, NULL)) != -1) {
>+		switch (opt) {
>+		case 'h':
>+			usage();
>+			return EXIT_SUCCESS;
>+		case 'l':
>+			break;
>+		case 'p':
>+			purge = true;
>+			break;
>+		default:
>+			fprintf(stderr, "Internal error: "
>+				"unexpected getopt value: %d\n", opt);
>+			usage();
>+			return EXIT_FAILURE;
>+		}
>+	}
>+
>+	drm_fd = open_render_node(&devid);
>+	drm_card = get_card_for_fd(drm_fd);
>+
>+	fprintf(stdout, "Found device id=0x%x\n", devid);
>+
>+	devinfo = intel_get_device_info(drm_fd);
>+	if (!devinfo) {
>+		fprintf(stderr, "No device info found.\n");
>+		return EXIT_FAILURE;
>+	}
>+
>+	fprintf(stdout, "Device graphics_ver=%i gt=%i\n", devinfo->graphics_ver, devinfo->gt);
>+
>+	perf = intel_xe_perf_for_fd(drm_fd, 0);
>+	if (!perf) {
>+		fprintf(stderr, "No perf data found.\n");
>+		return EXIT_FAILURE;
>+	}
>+
>+	snprintf(metrics_path, sizeof(metrics_path),
>+		 "/sys/class/drm/card%d/metrics", drm_card);
>+	metrics_dir = opendir(metrics_path);
>+	if (!metrics_dir)
>+		return EXIT_FAILURE;
>+
>+	fprintf(stdout, "Looking at metrics in %s\n", metrics_path);
>+
>+	while ((entry = readdir(metrics_dir))) {
>+		char metric_id_path[400];
>+		uint64_t metric_id;
>+
>+		if (entry->d_type != DT_DIR)
>+			continue;
>+
>+		snprintf(metric_id_path, sizeof(metric_id_path),
>+			 "%s/%s/id", metrics_path, entry->d_name);
>+
>+		if (!read_file_uint64(metric_id_path, &metric_id))
>+			continue;
>+
>+		if (purge) {
>+			if (intel_xe_perf_ioctl(drm_fd, DRM_XE_PERF_OP_REMOVE_CONFIG, &metric_id) == 0)
>+				fprintf(stdout, "\tRemoved config %s id=%03" PRIu64 " name=%s\n",
>+					entry->d_name, metric_id, metric_name(perf, entry->d_name));
>+			else
>+				fprintf(stdout, "\tFailed to remove config %s id=%03" PRIu64 " name=%s\n",
>+					entry->d_name, metric_id, metric_name(perf, entry->d_name));
>+		} else {
>+			fprintf(stdout, "\tConfig %s id=%03" PRIu64 " name=%s\n",
>+				entry->d_name, metric_id, metric_name(perf, entry->d_name));
>+		}
>+	}
>+
>+	closedir(metrics_dir);
>+	close(drm_fd);
>+
>+	return EXIT_SUCCESS;
>+}
>diff --git a/tools/xe-perf/xe_perf_control.c b/tools/xe-perf/xe_perf_control.c
>new file mode 100644
>index 0000000000..da96232bc8
>--- /dev/null
>+++ b/tools/xe-perf/xe_perf_control.c
>@@ -0,0 +1,117 @@
>+// SPDX-License-Identifier: MIT
>+/*
>+ * Copyright © 2024 Intel Corporation
>+ */
>+
>+
>+#include <getopt.h>
>+#include <stdbool.h>
>+#include <stdio.h>
>+#include <stdlib.h>
>+#include <string.h>
>+#include <unistd.h>
>+
>+#include "xe_perf_recorder_commands.h"
>+
>+static void
>+usage(const char *name)
>+{
>+	fprintf(stdout,
>+		"Usage: %s [options]\n"
>+		"\n"
>+		"     --help,               -h         Print this screen\n"
>+		"     --command-fifo,       -f <path>  Path to a command fifo\n"
>+		"     --dump,               -d <path>  Write a content of circular buffer to path\n",
>+		name);
>+}
>+
>+int
>+main(int argc, char *argv[])
>+{
>+	const struct option long_options[] = {
>+		{"help",                       no_argument, 0, 'h'},
>+		{"dump",                 required_argument, 0, 'd'},
>+		{"command-fifo",         required_argument, 0, 'f'},
>+		{"quit",                       no_argument, 0, 'q'},
>+		{0, 0, 0, 0}
>+	};
>+	const char *command_fifo = XE_PERF_RECORD_FIFO_PATH, *dump_file = NULL;
>+	FILE *command_fifo_file;
>+	int opt;
>+	bool quit = false;
>+
>+	while ((opt = getopt_long(argc, argv, "hd:f:q", long_options, NULL)) != -1) {
>+		switch (opt) {
>+		case 'h':
>+			usage(argv[0]);
>+			return EXIT_SUCCESS;
>+		case 'd':
>+			dump_file = optarg;
>+			break;
>+		case 'f':
>+			command_fifo = optarg;
>+			break;
>+		case 'q':
>+			quit = true;
>+			break;
>+		default:
>+			fprintf(stderr, "Internal error: "
>+				"unexpected getopt value: %d\n", opt);
>+			usage(argv[0]);
>+			return EXIT_FAILURE;
>+		}
>+	}
>+
>+	if (!command_fifo)
>+		return EXIT_FAILURE;
>+
>+	command_fifo_file = fopen(command_fifo, "r+");
>+	if (!command_fifo_file) {
>+		fprintf(stderr, "Unable to open command file\n");
>+		return EXIT_FAILURE;
>+	}
>+
>+	if (dump_file) {
>+		if (dump_file[0] == '/') {
>+			uint32_t total_len =
>+				sizeof(struct recorder_command_base) + strlen(dump_file) + 1;
>+			struct {
>+				struct recorder_command_base base;
>+				uint8_t dump[];
>+			} *data = malloc(total_len);
>+
>+			data->base.command = RECORDER_COMMAND_DUMP;
>+			data->base.size = total_len;
>+			snprintf((char *) data->dump, strlen(dump_file) + 1, "%s", dump_file);
>+
>+			fwrite(data, total_len, 1, command_fifo_file);
>+		} else {
>+			char *cwd = getcwd(NULL, 0);
>+			uint32_t path_len = strlen(cwd) + 1 + strlen(dump_file) + 1;
>+			uint32_t total_len = sizeof(struct recorder_command_base) + path_len;
>+			struct {
>+				struct recorder_command_base base;
>+				uint8_t dump[];
>+			} *data = malloc(total_len);
>+
>+			data->base.command = RECORDER_COMMAND_DUMP;
>+			data->base.size = total_len;
>+			snprintf((char *) data->dump, path_len, "%s/%s", cwd, dump_file);
>+
>+			fwrite(data, total_len, 1, command_fifo_file);
>+		}
>+	}
>+
>+	if (quit) {
>+		struct recorder_command_base base = {
>+			.command = RECORDER_COMMAND_QUIT,
>+			.size = sizeof(base),
>+		};
>+
>+		fwrite(&base, sizeof(base), 1, command_fifo_file);
>+	}
>+
>+	fclose(command_fifo_file);
>+
>+	return EXIT_SUCCESS;
>+}
>diff --git a/tools/xe-perf/xe_perf_reader.c b/tools/xe-perf/xe_perf_reader.c
>new file mode 100644
>index 0000000000..62a4237ee4
>--- /dev/null
>+++ b/tools/xe-perf/xe_perf_reader.c
>@@ -0,0 +1,325 @@
>+// SPDX-License-Identifier: MIT
>+/*
>+ * Copyright © 2024 Intel Corporation
>+ */
>+
>+#include <assert.h>
>+#include <errno.h>
>+#include <fcntl.h>
>+#include <getopt.h>
>+#include <inttypes.h>
>+#include <stdbool.h>
>+#include <stdint.h>
>+#include <stdio.h>
>+#include <stdlib.h>
>+#include <string.h>
>+#include <sys/types.h>
>+#include <sys/stat.h>
>+#include <unistd.h>
>+
>+#include "igt_core.h"
>+#include "intel_chipset.h"
>+#include "xe/xe_oa.h"
>+#include "xe/xe_oa_data_reader.h"
>+
>+#define MAX(a,b) ((a) > (b) ? (a) : (b))
>+#define MIN(a,b) ((a) > (b) ? (b) : (a))
>+
>+static void
>+usage(void)
>+{
>+	printf("Usage: xe-perf-reader [options] file\n"
>+	       "Reads the content of an xe-perf recording.\n"
>+	       "\n"
>+	       "     --help,    -h             Print this screen\n"
>+	       "     --counters, -c c1,c2,...  List of counters to display values for.\n"
>+	       "                               Use 'all' to display all counters.\n"
>+	       "                               Use 'list' to list available counters.\n"
>+	       "     --reports, -r             Print out data per report.\n");
>+}
>+
>+static struct intel_xe_perf_logical_counter *
>+find_counter(struct intel_xe_perf_metric_set *metric_set,
>+	     const char *name)
>+{
>+	for (uint32_t i = 0; i < metric_set->n_counters; i++) {
>+		if (!strcmp(name, metric_set->counters[i].symbol_name)) {
>+			return &metric_set->counters[i];
>+		}
>+	}
>+
>+	return NULL;
>+}
>+
>+static void
>+append_counter(struct intel_xe_perf_logical_counter ***counters,
>+	       int32_t *n_counters,
>+	       uint32_t *n_allocated_counters,
>+	       struct intel_xe_perf_logical_counter *counter)
>+{
>+	if (*n_counters < *n_allocated_counters) {
>+		(*counters)[(*n_counters)++] = counter;
>+		return;
>+	}
>+
>+	*n_allocated_counters = MAX(2, *n_allocated_counters * 2);
>+	*counters = realloc(*counters,
>+			    sizeof(struct intel_xe_perf_logical_counter *) *
>+			    (*n_allocated_counters));
>+	(*counters)[(*n_counters)++] = counter;
>+}
>+
>+static struct intel_xe_perf_logical_counter **
>+get_logical_counters(struct intel_xe_perf_metric_set *metric_set,
>+		     const char *counter_list,
>+		     int32_t *out_n_counters)
>+{
>+	struct intel_xe_perf_logical_counter **counters = NULL, *counter;
>+	uint32_t n_allocated_counters = 0;
>+	const char *current, *next;
>+	char counter_name[100];
>+
>+	if (!counter_list) {
>+		*out_n_counters = 0;
>+		return NULL;
>+	}
>+
>+	if (!strcmp(counter_list, "list")) {
>+		uint32_t longest_name = 0;
>+
>+		*out_n_counters = -1;
>+		for (uint32_t i = 0; i < metric_set->n_counters; i++) {
>+			longest_name = MAX(longest_name,
>+					   strlen(metric_set->counters[i].symbol_name));
>+		}
>+
>+		fprintf(stdout, "Available counters:\n");
>+		for (uint32_t i = 0; i < metric_set->n_counters; i++) {
>+			fprintf(stdout, "%s:%*s%s\n",
>+				metric_set->counters[i].symbol_name,
>+				(int)(longest_name -
>+				      strlen(metric_set->counters[i].symbol_name) + 1), " ",
>+				metric_set->counters[i].name);
>+		}
>+		return NULL;
>+	}
>+
>+	if (!strcmp(counter_list, "all")) {
>+		counters = malloc(sizeof(*counters) * metric_set->n_counters);
>+		*out_n_counters = metric_set->n_counters;
>+		for (uint32_t i = 0; i < metric_set->n_counters; i++)
>+			counters[i] = &metric_set->counters[i];
>+		return counters;
>+	}
>+
>+	*out_n_counters = 0;
>+	current = counter_list;
>+	while ((next = strstr(current, ","))) {
>+		snprintf(counter_name,
>+			 MIN((uint32_t)(next - current) + 1, sizeof(counter_name)),
>+			 "%s", current);
>+
>+		counter = find_counter(metric_set, counter_name);
>+		if (!counter) {
>+			fprintf(stderr, "Unknown counter '%s'.\n", counter_name);
>+			free(counters);
>+			*out_n_counters = -1;
>+			return NULL;
>+		}
>+
>+		append_counter(&counters, out_n_counters, &n_allocated_counters, counter);
>+
>+		current = next + 1;
>+	}
>+
>+	if (strlen(current) > 0) {
>+		counter = find_counter(metric_set, current);
>+		if (!counter) {
>+			fprintf(stderr, "Unknown counter '%s'.\n", current);
>+			free(counters);
>+			*out_n_counters = -1;
>+			return NULL;
>+		}
>+
>+		append_counter(&counters, out_n_counters, &n_allocated_counters, counter);
>+	}
>+
>+	return counters;
>+}
>+
>+static void
>+print_report_deltas(const struct intel_xe_perf_data_reader *reader,
>+		    const struct intel_xe_perf_record_header *xe_report0,
>+		    const struct intel_xe_perf_record_header *xe_report1,
>+		    struct intel_xe_perf_logical_counter **counters,
>+		    uint32_t n_counters)
>+{
>+	struct intel_xe_perf_accumulator accu;
>+
>+	intel_xe_perf_accumulate_reports(&accu,
>+				      reader->perf, reader->metric_set,
>+				      xe_report0, xe_report1);
>+
>+	for (uint32_t c = 0; c < n_counters; c++) {
>+		struct intel_xe_perf_logical_counter *counter = counters[c];
>+
>+		switch (counter->storage) {
>+		case INTEL_XE_PERF_LOGICAL_COUNTER_STORAGE_UINT64:
>+		case INTEL_XE_PERF_LOGICAL_COUNTER_STORAGE_UINT32:
>+		case INTEL_XE_PERF_LOGICAL_COUNTER_STORAGE_BOOL32:
>+			fprintf(stdout, "   %s: %" PRIu64 "\n",
>+				counter->symbol_name, counter->read_uint64(reader->perf,
>+									   reader->metric_set,
>+									   accu.deltas));
>+			break;
>+		case INTEL_XE_PERF_LOGICAL_COUNTER_STORAGE_DOUBLE:
>+		case INTEL_XE_PERF_LOGICAL_COUNTER_STORAGE_FLOAT:
>+			fprintf(stdout, "   %s: %f\n",
>+				counter->symbol_name, counter->read_float(reader->perf,
>+									  reader->metric_set,
>+									  accu.deltas));
>+			break;
>+		}
>+	}
>+}
>+
>+int
>+main(int argc, char *argv[])
>+{
>+	const struct option long_options[] = {
>+		{"help",             no_argument, 0, 'h'},
>+		{"counters",   required_argument, 0, 'c'},
>+		{"reports",          no_argument, 0, 'r'},
>+		{0, 0, 0, 0}
>+	};
>+	struct intel_xe_perf_data_reader reader;
>+	struct intel_xe_perf_logical_counter **counters;
>+	const struct intel_device_info *devinfo;
>+	const char *counter_names = NULL;
>+	int32_t n_counters;
>+	int fd, opt;
>+	bool print_reports = false;
>+
>+	while ((opt = getopt_long(argc, argv, "hc:r", long_options, NULL)) != -1) {
>+		switch (opt) {
>+		case 'h':
>+			usage();
>+			return EXIT_SUCCESS;
>+		case 'c':
>+			counter_names = optarg;
>+			break;
>+		case 'r':
>+			print_reports = true;
>+			break;
>+		default:
>+			fprintf(stderr, "Internal error: "
>+				"unexpected getopt value: %d\n", opt);
>+			usage();
>+			return EXIT_FAILURE;
>+		}
>+	}
>+
>+	if (optind >= argc) {
>+		fprintf(stderr, "No recording file specified.\n");
>+		return EXIT_FAILURE;
>+	}
>+
>+	fd = open(argv[optind], 0, O_RDONLY);
>+	if (fd < 0) {
>+		fprintf(stderr, "Cannot open '%s': %s.\n",
>+			argv[optind], strerror(errno));
>+		return EXIT_FAILURE;
>+	}
>+
>+	if (!intel_xe_perf_data_reader_init(&reader, fd)) {
>+		fprintf(stderr, "Unable to parse '%s': %s.\n",
>+			argv[optind], reader.error_msg);
>+		return EXIT_FAILURE;
>+	}
>+
>+	counters = get_logical_counters(reader.metric_set, counter_names, &n_counters);
>+	if (n_counters < 0)
>+		goto exit;
>+
>+	devinfo = intel_get_device_info(reader.devinfo.devid);
>+
>+	fprintf(stdout, "Recorded on device=0x%x(%s) graphics_ver=%i\n",
>+		reader.devinfo.devid, devinfo->codename,
>+		reader.devinfo.graphics_ver);
>+	fprintf(stdout, "Metric used : %s (%s) uuid=%s\n",
>+		reader.metric_set->symbol_name, reader.metric_set->name,
>+		reader.metric_set->hw_config_guid);
>+	fprintf(stdout, "Reports: %u\n", reader.n_records);
>+	fprintf(stdout, "Context switches: %u\n", reader.n_timelines);
>+	fprintf(stdout, "Timestamp correlation points: %u\n", reader.n_correlations);
>+
>+	if (reader.n_correlations < 2) {
>+		fprintf(stderr, "Less than 2 CPU/GPU timestamp correlation points.\n");
>+		return EXIT_FAILURE;
>+	}
>+
>+	fprintf(stdout, "Timestamp correlation CPU range:       0x%016"PRIx64"-0x%016"PRIx64"\n",
>+		reader.correlations[0]->cpu_timestamp,
>+		reader.correlations[reader.n_correlations - 1]->cpu_timestamp);
>+	fprintf(stdout, "Timestamp correlation GPU range (64b): 0x%016"PRIx64"-0x%016"PRIx64"\n",
>+		reader.correlations[0]->gpu_timestamp,
>+		reader.correlations[reader.n_correlations - 1]->gpu_timestamp);
>+	fprintf(stdout, "Timestamp correlation GPU range (32b): 0x%016"PRIx64"-0x%016"PRIx64"\n",
>+		reader.correlations[0]->gpu_timestamp & 0xffffffff,
>+		reader.correlations[reader.n_correlations - 1]->gpu_timestamp & 0xffffffff);
>+
>+	fprintf(stdout, "OA data timestamp range:               0x%016"PRIx64"-0x%016"PRIx64"\n",
>+		intel_xe_perf_read_record_timestamp(reader.perf,
>+						 reader.metric_set,
>+						 reader.records[0]),
>+		intel_xe_perf_read_record_timestamp(reader.perf,
>+						 reader.metric_set,
>+						 reader.records[reader.n_records - 1]));
>+	fprintf(stdout, "OA raw data timestamp range:           0x%016"PRIx64"-0x%016"PRIx64"\n",
>+		intel_xe_perf_read_record_timestamp_raw(reader.perf,
>+						     reader.metric_set,
>+						     reader.records[0]),
>+		intel_xe_perf_read_record_timestamp_raw(reader.perf,
>+						     reader.metric_set,
>+						     reader.records[reader.n_records - 1]));
>+
>+	if (strcmp(reader.metric_set_uuid, reader.metric_set->hw_config_guid)) {
>+		fprintf(stdout,
>+			"WARNING: Recording used a different HW configuration.\n"
>+			"WARNING: This could lead to inconsistent counter values.\n");
>+	}
>+
>+	for (uint32_t i = 0; i < reader.n_timelines; i++) {
>+		const struct intel_xe_perf_timeline_item *item = &reader.timelines[i];
>+
>+		fprintf(stdout, "Time: CPU=0x%016" PRIx64 "-0x%016" PRIx64
>+			" GPU=0x%016" PRIx64 "-0x%016" PRIx64"\n",
>+			item->cpu_ts_start, item->cpu_ts_end,
>+			item->ts_start, item->ts_end);
>+		fprintf(stdout, "hw_id=0x%x %s\n",
>+			item->hw_id, item->hw_id == 0xffffffff ? "(idle)" : "");
>+
>+		print_report_deltas(&reader,
>+				    reader.records[item->record_start],
>+				    reader.records[item->record_end],
>+				    counters, n_counters);
>+
>+		if (print_reports) {
>+			for (uint32_t r = item->record_start; r < item->record_end; r++) {
>+				fprintf(stdout, " report%i = %s\n",
>+					r - item->record_start,
>+					intel_xe_perf_read_report_reason(reader.perf, reader.records[r]));
>+				print_report_deltas(&reader,
>+						    reader.records[r],
>+						    reader.records[r + 1],
>+						    counters, n_counters);
>+			}
>+		}
>+	}
>+
>+ exit:
>+	intel_xe_perf_data_reader_fini(&reader);
>+	close(fd);
>+
>+	return EXIT_SUCCESS;
>+}
>-- 
>2.41.0
>