src/intel/tools/intel_monitor.c - third_party/mesa - Git at Google

 /*
  * Copyright 2024 Intel Corporation
  * SPDX-License-Identifier: MIT
  *
  * Purpose:
  *   Enables EU stall sampling available in Xe2+ Intel GPUs. Enables
  *   GPU sampling of EU stalls. Every N mircoseconds, program collects
  *   sampled data from GPU. Accumulated data dumped to stdout once
  *   intel_monitor is closed.
  */

 #include <fcntl.h>
 #include <getopt.h>
 #include <termios.h>

 #include <xf86drm.h>

 #include "intel_monitor_eustall.h"
 #include "dev/intel_device_info.h"

 static int
 get_drm_device(struct intel_device_info *devinfo)
 {
    drmDevicePtr devices[8];
    int max_devices = drmGetDevices2(0, devices, 8);

    int i, fd = -1;
    for (i = 0; i < max_devices; i++) {
       if (devices[i]->available_nodes & 1 << DRM_NODE_RENDER &&
           devices[i]->bustype == DRM_BUS_PCI &&
           devices[i]->deviceinfo.pci->vendor_id == 0x8086) {
          fd = open(devices[i]->nodes[DRM_NODE_RENDER], O_RDWR | O_CLOEXEC);
          if (fd < 0)
             continue;

          if (!intel_get_device_info_from_fd(fd, devinfo, -1, -1)) {
             close(fd);
             fd = -1;
             continue;
          }

          /* Found a device! */
          break;
       }
    }

    return fd;
 }

 /* Keyboard hit function
  *
  * Return true if keypress detected.
  */
 static bool
 kbhit()
 {
     int ch, oldf;
     struct termios oldt, newt;

     tcgetattr(STDIN_FILENO, &oldt);
     newt = oldt;
     newt.c_lflag &= ~(ICANON | ECHO);
     tcsetattr(STDIN_FILENO, TCSANOW, &newt);
     oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
     fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);

     ch = getchar();

     tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
     fcntl(STDIN_FILENO, F_SETFL, oldf);

     if (ch != EOF) {
         ungetc(ch, stdin);
         return true;
     }

     return false;
 }

 static void
 print_help(const char *progname, FILE *file)
 {
    fprintf(file,
       "\n"
       "Usage: %s [OPTION]...\n"
       "Sample and collate GPU metrics across system. Studies workloads run in parallel.\n"
       "      -h, --help            display this help\n"
       "      -e, --eustall         sample eu stalls. Supported Xe2+.\n"
       "      -f, --file            name of output file. DEFAULT=stdout\n"
       "      -t, --sample_time     period of sampling, in microseconds. DEFAULT=1000\n"
       "\n"
       "Eu stall sample usage:\n"
       "   0. Run `sudo sysctl dev.xe.observation_paranoid=0`\n"
       "   1. Launch gfx app with INTEL_DEBUG=shaders-lineno. Redirect stderr to asm.txt.\n"
       "   2. When gfx app ready to monitor, begin capturing eustall data by launching\n"
       "      `intel_monitor -e -f eustall.csv` in separate console.\n"
       "   3. When enough data has been collected, close intel_monitor by pressing any key.\n"
       "   4. Correlate eustall data in eustall.csv with shader instructions in asm.txt by\n"
       "      matching instruction offsets. Use data to determine which instructions are\n"
       "      stalling and why.\n"
       "\n"
       "Eu stall defintions:\n"
       "tdr_count        - Number of cycles EU stalled, with at least one thread waiting\n"
       "                   on Pixel Shader dependency. Multiple stall reasons can\n"
       "                   qualify during the same cycle.\n"
       "other_count      - Number of cycles EU stalled, with at least one thread waiting\n"
       "                   on any other dependency (Flag/EoT etc). Multiple stall reasons\n"
       "                   can qualify during the same cycle.\n"
       "control_count    - Number of cycles EU stalled, with at least one thread waiting\n"
       "                   for JEU to complete branch instruction. Multiple stall reasons\n"
       "                   can qualify during the same cycle.\n"
       "pipestall_count  - Number of cycles EU stalled, with at least one thread ready to\n"
       "                   be scheduled (Grf conf/send holds etc). Multiple stall reasons\n"
       "                   can qualify during the same cycle.\n"
       "send_count       - Number of cycles EU stalled, with at least one thread waiting\n"
       "                   for SEND message to be dispatched from EU. Multiple stall\n"
       "                   reasons can qualify during the same cycle.\n"
       "dist_acc_count   - Number of cycles EU stalled, with at least one thread waiting\n"
       "                   for ALU to write GRF/ACC register. Multiple stall reasons can\n"
       "                   qualify during the same cycle.\n"
       "sbid_count       - Number of cycles EU stalled, with at least one thread waiting\n"
       "                   for Scoreboard token to be available. Multiple stall reasons\n"
       "                   can qualify during the same cycle.\n"
       "sync_count       - Number of cycles EU stalled, with at least one thread waiting\n"
       "                   for Gateway to write Notify register. Multiple stall reasons\n"
       "                   can qualify during the same cycle.\n"
       "inst_fetch_count - Number of cycles EU stalled, with at least one thread waiting\n"
       "                   for Instruction Fetch. Multiple stall reasons can qualify\n"
       "                   during the same cycle.\n"
       "active_count     - Number of cycles no EU stalled.\n\n",
       progname);
 }

 enum intel_monitor_sampling_mode
 {
    /* No sampling requested */
    INTEL_MONITOR_MODE_NONE = 0,

    /* Sample eu stalls */
    INTEL_MONITOR_MODE_EUSTALL = 1
 };

 int
 main(int argc, char *argv[])
 {
    int c, i;
    FILE *fd_out = stdout;
    uint64_t sample_period_us = 1000;
    bool success = true;

    void *cfg = NULL;
    bool (*do_sample)(void*) = NULL;
    void (*do_dump_results)(void*, FILE*) = NULL;
    void (*do_close)(void*) = NULL;

    enum intel_monitor_sampling_mode sample_mode = INTEL_MONITOR_MODE_NONE;
    const struct option intel_monitor_opts[] = {
       { "help",         no_argument,       NULL, 'h' },
       { "eustall",      no_argument,       NULL, 'e' },
       { "file",         required_argument, NULL, 'f' },
       { "sample_time",  required_argument, NULL, 't' },
       { NULL,           0,                 NULL, 0 }
    };

    struct intel_device_info devinfo;
    int drm_fd = get_drm_device(&devinfo);
    if (drm_fd < 0) {
       fprintf(stderr, "IMON: Error encountered while getting drm_device. err=%i\n",
               drm_fd);
       exit(EXIT_FAILURE);
    }

    /* Parse arguments */
    while ((c = getopt_long(argc, argv, "hef:t:", intel_monitor_opts, &i)) != -1) {
       switch (c) {
       case 'h':
          print_help(argv[0], stderr);
          return EXIT_SUCCESS;
       case 'e':
          sample_mode = INTEL_MONITOR_MODE_EUSTALL;
          break;
       case 'f':
          fd_out = fopen(optarg, "w");
          if (!fd_out) {
             fprintf(stderr, "IMON: Error opening output file '%s'\n", optarg);
             exit(EXIT_FAILURE);
          }
          break;
       case 't':
          sample_period_us = atoi(optarg);
          break;
       default:
          fprintf(stderr,
                  "IMON: Error. Unexpected parameter encountered '%c'.\n", c);
          exit(EXIT_FAILURE);
       }
    }

    /* Setup cfg based on selected sampling mode */
    if (sample_mode == INTEL_MONITOR_MODE_EUSTALL) {
       fprintf(stderr, "IMON: Setting up EU Stall Sampling\n");
       if (devinfo.ver < 20) {
          fprintf(stderr, "IMON: EU Stall Sampler supported on Xe2+ platforms.\n");
          exit(EXIT_FAILURE);
       }

       cfg = eustall_setup(drm_fd, &devinfo);

       do_sample = eustall_sample;
       do_dump_results = eustall_dump_results;
       do_close = eustall_close;
    } else {
       fprintf(stderr,
               "IMON: Error. No sampling mode set. Modes supported: ['-e']\n");
       exit(EXIT_FAILURE);
    }

    /* Main loop */
    fprintf(stderr, "IMON: Collecting samples. <Press any key to stop>\n");
    while (!kbhit()) {
       if (!success)
          exit(EXIT_FAILURE);

       success = do_sample(cfg);
       usleep(sample_period_us);
    }

    fprintf(stderr, "IMON: Dumping results\n");
    do_dump_results(cfg, fd_out);
    do_close(cfg);
    fprintf(stderr, "IMON: done\n");

    return EXIT_SUCCESS;
 }
	/*
	* Copyright 2024 Intel Corporation
	* SPDX-License-Identifier: MIT
	*
	* Purpose:
	* Enables EU stall sampling available in Xe2+ Intel GPUs. Enables
	* GPU sampling of EU stalls. Every N mircoseconds, program collects
	* sampled data from GPU. Accumulated data dumped to stdout once
	* intel_monitor is closed.
	*/

	#include <fcntl.h>
	#include <getopt.h>
	#include <termios.h>

	#include <xf86drm.h>

	#include "intel_monitor_eustall.h"
	#include "dev/intel_device_info.h"

	static int
	get_drm_device(struct intel_device_info *devinfo)
	{
	drmDevicePtr devices[8];
	int max_devices = drmGetDevices2(0, devices, 8);

	int i, fd = -1;
	for (i = 0; i < max_devices; i++) {
	if (devices[i]->available_nodes & 1 << DRM_NODE_RENDER &&
	devices[i]->bustype == DRM_BUS_PCI &&
	devices[i]->deviceinfo.pci->vendor_id == 0x8086) {
	fd = open(devices[i]->nodes[DRM_NODE_RENDER], O_RDWR \| O_CLOEXEC);
	if (fd < 0)
	continue;

	if (!intel_get_device_info_from_fd(fd, devinfo, -1, -1)) {
	close(fd);
	fd = -1;
	continue;
	}

	/* Found a device! */
	break;
	}
	}

	return fd;
	}

	/* Keyboard hit function
	*
	* Return true if keypress detected.
	*/
	static bool
	kbhit()
	{
	int ch, oldf;
	struct termios oldt, newt;

	tcgetattr(STDIN_FILENO, &oldt);
	newt = oldt;
	newt.c_lflag &= ~(ICANON \| ECHO);
	tcsetattr(STDIN_FILENO, TCSANOW, &newt);
	oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
	fcntl(STDIN_FILENO, F_SETFL, oldf \| O_NONBLOCK);

	ch = getchar();

	tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
	fcntl(STDIN_FILENO, F_SETFL, oldf);

	if (ch != EOF) {
	ungetc(ch, stdin);
	return true;
	}

	return false;
	}

	static void
	print_help(const char progname, FILE file)
	{
	fprintf(file,
	"\n"
	"Usage: %s [OPTION]...\n"
	"Sample and collate GPU metrics across system. Studies workloads run in parallel.\n"
	" -h, --help display this help\n"
	" -e, --eustall sample eu stalls. Supported Xe2+.\n"
	" -f, --file name of output file. DEFAULT=stdout\n"
	" -t, --sample_time period of sampling, in microseconds. DEFAULT=1000\n"
	"\n"
	"Eu stall sample usage:\n"
	" 0. Run `sudo sysctl dev.xe.observation_paranoid=0`\n"
	" 1. Launch gfx app with INTEL_DEBUG=shaders-lineno. Redirect stderr to asm.txt.\n"
	" 2. When gfx app ready to monitor, begin capturing eustall data by launching\n"
	" `intel_monitor -e -f eustall.csv` in separate console.\n"
	" 3. When enough data has been collected, close intel_monitor by pressing any key.\n"
	" 4. Correlate eustall data in eustall.csv with shader instructions in asm.txt by\n"
	" matching instruction offsets. Use data to determine which instructions are\n"
	" stalling and why.\n"
	"\n"
	"Eu stall defintions:\n"
	"tdr_count - Number of cycles EU stalled, with at least one thread waiting\n"
	" on Pixel Shader dependency. Multiple stall reasons can\n"
	" qualify during the same cycle.\n"
	"other_count - Number of cycles EU stalled, with at least one thread waiting\n"
	" on any other dependency (Flag/EoT etc). Multiple stall reasons\n"
	" can qualify during the same cycle.\n"
	"control_count - Number of cycles EU stalled, with at least one thread waiting\n"
	" for JEU to complete branch instruction. Multiple stall reasons\n"
	" can qualify during the same cycle.\n"
	"pipestall_count - Number of cycles EU stalled, with at least one thread ready to\n"
	" be scheduled (Grf conf/send holds etc). Multiple stall reasons\n"
	" can qualify during the same cycle.\n"
	"send_count - Number of cycles EU stalled, with at least one thread waiting\n"
	" for SEND message to be dispatched from EU. Multiple stall\n"
	" reasons can qualify during the same cycle.\n"
	"dist_acc_count - Number of cycles EU stalled, with at least one thread waiting\n"
	" for ALU to write GRF/ACC register. Multiple stall reasons can\n"
	" qualify during the same cycle.\n"
	"sbid_count - Number of cycles EU stalled, with at least one thread waiting\n"
	" for Scoreboard token to be available. Multiple stall reasons\n"
	" can qualify during the same cycle.\n"
	"sync_count - Number of cycles EU stalled, with at least one thread waiting\n"
	" for Gateway to write Notify register. Multiple stall reasons\n"
	" can qualify during the same cycle.\n"
	"inst_fetch_count - Number of cycles EU stalled, with at least one thread waiting\n"
	" for Instruction Fetch. Multiple stall reasons can qualify\n"
	" during the same cycle.\n"
	"active_count - Number of cycles no EU stalled.\n\n",
	progname);
	}

	enum intel_monitor_sampling_mode
	{
	/* No sampling requested */
	INTEL_MONITOR_MODE_NONE = 0,

	/* Sample eu stalls */
	INTEL_MONITOR_MODE_EUSTALL = 1
	};

	int
	main(int argc, char *argv[])
	{
	int c, i;
	FILE *fd_out = stdout;
	uint64_t sample_period_us = 1000;
	bool success = true;

	void *cfg = NULL;
	bool (do_sample)(void) = NULL;
	void (do_dump_results)(void, FILE*) = NULL;
	void (do_close)(void) = NULL;

	enum intel_monitor_sampling_mode sample_mode = INTEL_MONITOR_MODE_NONE;
	const struct option intel_monitor_opts[] = {
	{ "help", no_argument, NULL, 'h' },
	{ "eustall", no_argument, NULL, 'e' },
	{ "file", required_argument, NULL, 'f' },
	{ "sample_time", required_argument, NULL, 't' },
	{ NULL, 0, NULL, 0 }
	};

	struct intel_device_info devinfo;
	int drm_fd = get_drm_device(&devinfo);
	if (drm_fd < 0) {
	fprintf(stderr, "IMON: Error encountered while getting drm_device. err=%i\n",
	drm_fd);
	exit(EXIT_FAILURE);
	}

	/* Parse arguments */
	while ((c = getopt_long(argc, argv, "hef:t:", intel_monitor_opts, &i)) != -1) {
	switch (c) {
	case 'h':
	print_help(argv[0], stderr);
	return EXIT_SUCCESS;
	case 'e':
	sample_mode = INTEL_MONITOR_MODE_EUSTALL;
	break;
	case 'f':
	fd_out = fopen(optarg, "w");
	if (!fd_out) {
	fprintf(stderr, "IMON: Error opening output file '%s'\n", optarg);
	exit(EXIT_FAILURE);
	}
	break;
	case 't':
	sample_period_us = atoi(optarg);
	break;
	default:
	fprintf(stderr,
	"IMON: Error. Unexpected parameter encountered '%c'.\n", c);
	exit(EXIT_FAILURE);
	}
	}

	/* Setup cfg based on selected sampling mode */
	if (sample_mode == INTEL_MONITOR_MODE_EUSTALL) {
	fprintf(stderr, "IMON: Setting up EU Stall Sampling\n");
	if (devinfo.ver < 20) {
	fprintf(stderr, "IMON: EU Stall Sampler supported on Xe2+ platforms.\n");
	exit(EXIT_FAILURE);
	}

	cfg = eustall_setup(drm_fd, &devinfo);

	do_sample = eustall_sample;
	do_dump_results = eustall_dump_results;
	do_close = eustall_close;
	} else {
	fprintf(stderr,
	"IMON: Error. No sampling mode set. Modes supported: ['-e']\n");
	exit(EXIT_FAILURE);
	}

	/* Main loop */
	fprintf(stderr, "IMON: Collecting samples. <Press any key to stop>\n");
	while (!kbhit()) {
	if (!success)
	exit(EXIT_FAILURE);

	success = do_sample(cfg);
	usleep(sample_period_us);
	}

	fprintf(stderr, "IMON: Dumping results\n");
	do_dump_results(cfg, fd_out);
	do_close(cfg);
	fprintf(stderr, "IMON: done\n");

	return EXIT_SUCCESS;
	}