src/intel/perf/gen_perf.h

   1 /*
   2  * Copyright © 2018 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #ifndef GEN_PERF_H
  25 #define GEN_PERF_H
  26
  27 #include <stdio.h>
  28 #include <stdint.h>
  29 #include <string.h>
  30
  31 #if defined(MAJOR_IN_SYSMACROS)
  32 #include <sys/sysmacros.h>
  33 #elif defined(MAJOR_IN_MKDEV)
  34 #include <sys/mkdev.h>
  35 #endif
  36
  37 #include "util/hash_table.h"
  38 #include "compiler/glsl/list.h"
  39 #include "util/ralloc.h"
  40
  41 struct gen_device_info;
  42
  43 struct gen_perf_config;
  44 struct gen_perf_query_info;
  45
  46 enum gen_perf_counter_type {
  47    GEN_PERF_COUNTER_TYPE_EVENT,
  48    GEN_PERF_COUNTER_TYPE_DURATION_NORM,
  49    GEN_PERF_COUNTER_TYPE_DURATION_RAW,
  50    GEN_PERF_COUNTER_TYPE_THROUGHPUT,
  51    GEN_PERF_COUNTER_TYPE_RAW,
  52    GEN_PERF_COUNTER_TYPE_TIMESTAMP,
  53 };
  54
  55 enum gen_perf_counter_data_type {
  56    GEN_PERF_COUNTER_DATA_TYPE_BOOL32,
  57    GEN_PERF_COUNTER_DATA_TYPE_UINT32,
  58    GEN_PERF_COUNTER_DATA_TYPE_UINT64,
  59    GEN_PERF_COUNTER_DATA_TYPE_FLOAT,
  60    GEN_PERF_COUNTER_DATA_TYPE_DOUBLE,
  61 };
  62
  63 struct gen_pipeline_stat {
  64    uint32_t reg;
  65    uint32_t numerator;
  66    uint32_t denominator;
  67 };
  68
  69 /*
  70  * The largest OA formats we can use include:
  71  * For Haswell:
  72  *   1 timestamp, 45 A counters, 8 B counters and 8 C counters.
  73  * For Gen8+
  74  *   1 timestamp, 1 clock, 36 A counters, 8 B counters and 8 C counters
  75  */
  76 #define MAX_OA_REPORT_COUNTERS 62
  77
  78 /*
  79  * When currently allocate only one page for pipeline statistics queries. Here
  80  * we derived the maximum number of counters for that amount.
  81  */
  82 #define STATS_BO_SIZE               4096
  83 #define STATS_BO_END_OFFSET_BYTES   (STATS_BO_SIZE / 2)
  84 #define MAX_STAT_COUNTERS           (STATS_BO_END_OFFSET_BYTES / 8)
  85
  86 #define I915_PERF_OA_SAMPLE_SIZE (8 +   /* drm_i915_perf_record_header */ \
  87                                   256)  /* OA counter report */
  88
  89 struct gen_perf_query_result {
  90    /**
  91     * Storage for the final accumulated OA counters.
  92     */
  93    uint64_t accumulator[MAX_OA_REPORT_COUNTERS];
  94
  95    /**
  96     * Hw ID used by the context on which the query was running.
  97     */
  98    uint32_t hw_id;
  99
 100    /**
 101     * Number of reports accumulated to produce the results.
 102     */
 103    uint32_t reports_accumulated;
 104
 105    /**
 106     * Frequency in the slices of the GT at the begin and end of the
 107     * query.
 108     */
 109    uint64_t slice_frequency[2];
 110
 111    /**
 112     * Frequency in the unslice of the GT at the begin and end of the
 113     * query.
 114     */
 115    uint64_t unslice_frequency[2];
 116
 117    /**
 118     * Timestamp of the query.
 119     */
 120    uint64_t begin_timestamp;
 121 };
 122
 123 struct gen_perf_query_counter {
 124    const char *name;
 125    const char *desc;
 126    enum gen_perf_counter_type type;
 127    enum gen_perf_counter_data_type data_type;
 128    uint64_t raw_max;
 129    size_t offset;
 130
 131    union {
 132       uint64_t (*oa_counter_read_uint64)(struct gen_perf_config *perf,
 133                                          const struct gen_perf_query_info *query,
 134                                          const uint64_t *accumulator);
 135       float (*oa_counter_read_float)(struct gen_perf_config *perf,
 136                                      const struct gen_perf_query_info *query,
 137                                      const uint64_t *accumulator);
 138       struct gen_pipeline_stat pipeline_stat;
 139    };
 140 };
 141
 142 struct gen_perf_query_register_prog {
 143    uint32_t reg;
 144    uint32_t val;
 145 };
 146
 147 /* Register programming for a given query */
 148 struct gen_perf_registers {
 149    struct gen_perf_query_register_prog *flex_regs;
 150    uint32_t n_flex_regs;
 151
 152    struct gen_perf_query_register_prog *mux_regs;
 153    uint32_t n_mux_regs;
 154
 155    struct gen_perf_query_register_prog *b_counter_regs;
 156    uint32_t n_b_counter_regs;
 157 };
 158
 159 struct gen_perf_query_info {
 160    enum gen_perf_query_type {
 161       GEN_PERF_QUERY_TYPE_OA,
 162       GEN_PERF_QUERY_TYPE_RAW,
 163       GEN_PERF_QUERY_TYPE_PIPELINE,
 164    } kind;
 165    const char *name;
 166    const char *guid;
 167    struct gen_perf_query_counter *counters;
 168    int n_counters;
 169    int max_counters;
 170    size_t data_size;
 171
 172    /* OA specific */
 173    uint64_t oa_metrics_set_id;
 174    int oa_format;
 175
 176    /* For indexing into the accumulator[] ... */
 177    int gpu_time_offset;
 178    int gpu_clock_offset;
 179    int a_offset;
 180    int b_offset;
 181    int c_offset;
 182
 183    struct gen_perf_registers config;
 184 };
 185
 186 struct gen_perf_config {
 187    bool i915_query_supported;
 188
 189    struct gen_perf_query_info *queries;
 190    int n_queries;
 191
 192    /* Variables referenced in the XML meta data for OA performance
 193     * counters, e.g in the normalization equations.
 194     *
 195     * All uint64_t for consistent operand types in generated code
 196     */
 197    struct {
 198       uint64_t timestamp_frequency; /** $GpuTimestampFrequency */
 199       uint64_t n_eus;               /** $EuCoresTotalCount */
 200       uint64_t n_eu_slices;         /** $EuSlicesTotalCount */
 201       uint64_t n_eu_sub_slices;     /** $EuSubslicesTotalCount */
 202       uint64_t eu_threads_count;    /** $EuThreadsCount */
 203       uint64_t slice_mask;          /** $SliceMask */
 204       uint64_t subslice_mask;       /** $SubsliceMask */
 205       uint64_t gt_min_freq;         /** $GpuMinFrequency */
 206       uint64_t gt_max_freq;         /** $GpuMaxFrequency */
 207       uint64_t revision;            /** $SkuRevisionId */
 208    } sys_vars;
 209
 210    /* OA metric sets, indexed by GUID, as know by Mesa at build time, to
 211     * cross-reference with the GUIDs of configs advertised by the kernel at
 212     * runtime
 213     */
 214    struct hash_table *oa_metrics_table;
 215
 216    /* Location of the device's sysfs entry. */
 217    char sysfs_dev_dir[256];
 218
 219    struct {
 220       void *(*bo_alloc)(void *bufmgr, const char *name, uint64_t size);
 221       void (*bo_unreference)(void *bo);
 222       void *(*bo_map)(void *ctx, void *bo, unsigned flags);
 223       void (*bo_unmap)(void *bo);
 224       bool (*batch_references)(void *batch, void *bo);
 225       void (*bo_wait_rendering)(void *bo);
 226       int (*bo_busy)(void *bo);
 227       void (*emit_stall_at_pixel_scoreboard)(void *ctx);
 228       void (*emit_mi_report_perf_count)(void *ctx,
 229                                         void *bo,
 230                                         uint32_t offset_in_bytes,
 231                                         uint32_t report_id);
 232       void (*batchbuffer_flush)(void *ctx,
 233                                 const char *file, int line);
 234       void (*store_register_mem)(void *ctx, void *bo, uint32_t reg, uint32_t reg_size, uint32_t offset);
 235
 236    } vtbl;
 237 };
 238
 239 struct gen_perf_query_object;
 240 const struct gen_perf_query_info* gen_perf_query_info(const struct gen_perf_query_object *);
 241
 242 void gen_perf_init_metrics(struct gen_perf_config *perf_cfg,
 243                            const struct gen_device_info *devinfo,
 244                            int drm_fd);
 245
 246 /** Query i915 for a metric id using guid.
 247  */
 248 bool gen_perf_load_metric_id(struct gen_perf_config *perf_cfg,
 249                              const char *guid,
 250                              uint64_t *metric_id);
 251
 252 /** Load a configuation's content from i915 using a guid.
 253  */
 254 struct gen_perf_registers *gen_perf_load_configuration(struct gen_perf_config *perf_cfg,
 255                                                       int fd, const char *guid);
 256
 257 /** Store a configuration into i915 using guid and return a new metric id.
 258  *
 259  * If guid is NULL, then a generated one will be provided by hashing the
 260  * content of the configuration.
 261  */
 262 uint64_t gen_perf_store_configuration(struct gen_perf_config *perf_cfg, int fd,
 263                                       const struct gen_perf_registers *config,
 264                                       const char *guid);
 265
 266 /** Read the slice/unslice frequency from 2 OA reports and store then into
 267  *  result.
 268  */
 269 void gen_perf_query_result_read_frequencies(struct gen_perf_query_result *result,
 270                                             const struct gen_device_info *devinfo,
 271                                             const uint32_t *start,
 272                                             const uint32_t *end);
 273 /** Accumulate the delta between 2 OA reports into result for a given query.
 274  */
 275 void gen_perf_query_result_accumulate(struct gen_perf_query_result *result,
 276                                       const struct gen_perf_query_info *query,
 277                                       const uint32_t *start,
 278                                       const uint32_t *end);
 279 void gen_perf_query_result_clear(struct gen_perf_query_result *result);
 280
 281 struct gen_perf_context;
 282 struct gen_perf_context *gen_perf_new_context(void *parent);
 283
 284 void gen_perf_init_context(struct gen_perf_context *perf_ctx,
 285                            struct gen_perf_config *perf_cfg,
 286                            void * ctx,  /* driver context (eg, brw_context) */
 287                            void * bufmgr,  /* eg brw_bufmgr */
 288                            const struct gen_device_info *devinfo,
 289                            uint32_t hw_ctx,
 290                            int drm_fd);
 291
 292 struct gen_perf_config *gen_perf_config(struct gen_perf_context *ctx);
 293
 294 int gen_perf_active_queries(struct gen_perf_context *perf_ctx,
 295                             const struct gen_perf_query_info *query);
 296
 297 static inline size_t
 298 gen_perf_query_counter_get_size(const struct gen_perf_query_counter *counter)
 299 {
 300    switch (counter->data_type) {
 301    case GEN_PERF_COUNTER_DATA_TYPE_BOOL32:
 302       return sizeof(uint32_t);
 303    case GEN_PERF_COUNTER_DATA_TYPE_UINT32:
 304       return sizeof(uint32_t);
 305    case GEN_PERF_COUNTER_DATA_TYPE_UINT64:
 306       return sizeof(uint64_t);
 307    case GEN_PERF_COUNTER_DATA_TYPE_FLOAT:
 308       return sizeof(float);
 309    case GEN_PERF_COUNTER_DATA_TYPE_DOUBLE:
 310       return sizeof(double);
 311    default:
 312       unreachable("invalid counter data type");
 313    }
 314 }
 315
 316 static inline struct gen_perf_config *
 317 gen_perf_new(void *ctx)
 318 {
 319    struct gen_perf_config *perf = rzalloc(ctx, struct gen_perf_config);
 320    return perf;
 321 }
 322
 323 struct gen_perf_query_object *
 324 gen_perf_new_query(struct gen_perf_context *, unsigned query_index);
 325
 326
 327 bool gen_perf_begin_query(struct gen_perf_context *perf_ctx,
 328                           struct gen_perf_query_object *query);
 329 void gen_perf_end_query(struct gen_perf_context *perf_ctx,
 330                         struct gen_perf_query_object *query);
 331 void gen_perf_wait_query(struct gen_perf_context *perf_ctx,
 332                          struct gen_perf_query_object *query,
 333                          void *current_batch);
 334 bool gen_perf_is_query_ready(struct gen_perf_context *perf_ctx,
 335                              struct gen_perf_query_object *query,
 336                              void *current_batch);
 337 void gen_perf_delete_query(struct gen_perf_context *perf_ctx,
 338                            struct gen_perf_query_object *query);
 339 void gen_perf_get_query_data(struct gen_perf_context *perf_ctx,
 340                              struct gen_perf_query_object *query,
 341                              int data_size,
 342                              unsigned *data,
 343                              unsigned *bytes_written);
 344
 345 void gen_perf_dump_query_count(struct gen_perf_context *perf_ctx);
 346 void gen_perf_dump_query(struct gen_perf_context *perf_ctx,
 347                          struct gen_perf_query_object *obj,
 348                          void *current_batch);
 349
 350 #endif /* GEN_PERF_H */