IABSD.fr/xenocara/lib/mesa/src/intel/perf/intel_perf_query_layout.c

Branch : - branch - master - tag -

• Show log

  Commit

• Author : jsg
  Date : 2025-06-05 11:23:11
  Hash : 67d6f117
  Message : Import Mesa 25.0.7

• lib/mesa/src/intel/perf/intel_perf_query_layout.c

• /*
   * Copyright © 2020 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 <stdio.h>
  #include <stdlib.h>
  #include <getopt.h>
  
  #include "dev/intel_debug.h"
  #include "dev/intel_device_info.h"
  #include "intel_perf.h"
  
  static void
  print_help(const char *name)
  {
     fprintf(stdout, "%s -p <platform> ...\n", name);
     fprintf(stdout, "    -p/--platform      <platform>  Platform to use (skl, icl, tgl, etc...)\n");
     fprintf(stdout, "    -P/--print-metric  <name>      Print a given metric set\n");
  }
  
  static void
  print_metric_set(const struct intel_perf_query_info *metric_set)
  {
     for (uint32_t c = 0; c < metric_set->n_counters; c++) {
        const struct intel_perf_query_counter *counter = &metric_set->counters[c];
        fprintf(stdout, "   %s: offset=%zx/0x%zx name=%s\n",
                counter->symbol_name, counter->offset, counter->offset, counter->name);
     }
  }
  
  int
  main(int argc, char *argv[])
  {
     const struct option perf_opts[] = {
        { "help",          no_argument,       NULL, 'h' },
        { "platform",      required_argument, NULL, 'p' },
        { "print-metric",  required_argument, NULL, 'P' },
        { NULL,            0,                 NULL,  0  }
     };
     const char *platform_name = NULL, *print_metric = NULL;
  
     int o = 0;
     while ((o = getopt_long(argc, argv, "hp:P:a", perf_opts, NULL)) != -1) {
        switch (o) {
        case 'h':
           print_help(argv[0]);
           return EXIT_SUCCESS;
        case 'p':
           platform_name = optarg;
           break;
        case 'P':
           print_metric = optarg;
           break;
        default:
           break;
        }
     }
  
     if (!platform_name) {
        fprintf(stderr, "No platform specified.\n");
        return EXIT_FAILURE;
     }
  
     int devid = intel_device_name_to_pci_device_id(platform_name);
     if (!devid) {
        fprintf(stderr, "Invalid platform name.\n");
        return EXIT_FAILURE;
     }
  
     struct intel_device_info devinfo;
     if (!intel_get_device_info_from_pci_id(devid, &devinfo)) {
        fprintf(stderr, "Unknown platform.\n");
        return EXIT_FAILURE;
     }
  
     /* Force metric loading. */
     intel_debug |= DEBUG_NO_OACONFIG;
  
     struct intel_perf_config *perf_cfg = intel_perf_new(NULL);
     intel_perf_init_metrics(perf_cfg, &devinfo, -1, true, true);
  
     if (!(perf_cfg->features_supported & INTEL_PERF_FEATURE_QUERY_PERF)) {
        fprintf(stderr, "No supported queries for platform.\n");
        intel_perf_free(perf_cfg);
        return EXIT_FAILURE;
     }
  
     if (print_metric) {
        bool found = false;
        for (uint32_t i = 0; i < perf_cfg->n_queries; i++) {
           const struct intel_perf_query_info *metric_set = &perf_cfg->queries[i];
  
           if (metric_set->symbol_name && !strcmp(metric_set->symbol_name, print_metric)) {
              fprintf(stdout, "%s name=%s size=%zx counters=%u:\n",
                      metric_set->symbol_name, metric_set->name,
                      metric_set->data_size, metric_set->n_counters);
              print_metric_set(metric_set);
              found = true;
              break;
           }
        }
  
        if (!found) {
           fprintf(stderr, "Unknown metric '%s'.\n", print_metric);
           return EXIT_FAILURE;
        }
     } else {
        for (uint32_t i = 0; i < perf_cfg->n_queries; i++) {
           const struct intel_perf_query_info *metric_set = &perf_cfg->queries[i];
  
           fprintf(stdout, "%s name=%s size=%zx counters=%u:\n",
                   metric_set->symbol_name, metric_set->name,
                   metric_set->data_size, metric_set->n_counters);
           print_metric_set(metric_set);
        }
     }
  
     intel_perf_free(perf_cfg);
     return EXIT_SUCCESS;
  }