src/intel/perf/gen_perf_mdapi.c

   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 #include "gen_perf.h"
  25 #include "gen_perf_mdapi.h"
  26 #include "gen_perf_private.h"
  27 #include "gen_perf_regs.h"
  28
  29 #include "dev/gen_device_info.h"
  30
  31 #include <drm-uapi/i915_drm.h>
  32
  33
  34 int
  35 gen_perf_query_result_write_mdapi(void *data, uint32_t data_size,
  36                                   const struct gen_device_info *devinfo,
  37                                   const struct gen_perf_query_result *result,
  38                                   uint64_t freq_start, uint64_t freq_end)
  39 {
  40    switch (devinfo->gen) {
  41    case 7: {
  42       struct gen7_mdapi_metrics *mdapi_data = (struct gen7_mdapi_metrics *) data;
  43
  44       if (data_size < sizeof(*mdapi_data))
  45          return 0;
  46
  47       assert(devinfo->is_haswell);
  48
  49       for (int i = 0; i < ARRAY_SIZE(mdapi_data->ACounters); i++)
  50          mdapi_data->ACounters[i] = result->accumulator[1 + i];
  51
  52       for (int i = 0; i < ARRAY_SIZE(mdapi_data->NOACounters); i++) {
  53          mdapi_data->NOACounters[i] =
  54             result->accumulator[1 + ARRAY_SIZE(mdapi_data->ACounters) + i];
  55       }
  56
  57       mdapi_data->ReportsCount = result->reports_accumulated;
  58       mdapi_data->TotalTime =
  59          gen_device_info_timebase_scale(devinfo, result->accumulator[0]);
  60       mdapi_data->CoreFrequency = freq_end;
  61       mdapi_data->CoreFrequencyChanged = freq_end != freq_start;
  62       mdapi_data->SplitOccured = result->query_disjoint;
  63       return sizeof(*mdapi_data);
  64    }
  65    case 8: {
  66       struct gen8_mdapi_metrics *mdapi_data = (struct gen8_mdapi_metrics *) data;
  67
  68       if (data_size < sizeof(*mdapi_data))
  69          return 0;
  70
  71       for (int i = 0; i < ARRAY_SIZE(mdapi_data->OaCntr); i++)
  72          mdapi_data->OaCntr[i] = result->accumulator[2 + i];
  73       for (int i = 0; i < ARRAY_SIZE(mdapi_data->NoaCntr); i++) {
  74          mdapi_data->NoaCntr[i] =
  75             result->accumulator[2 + ARRAY_SIZE(mdapi_data->OaCntr) + i];
  76       }
  77
  78       mdapi_data->ReportId = result->hw_id;
  79       mdapi_data->ReportsCount = result->reports_accumulated;
  80       mdapi_data->TotalTime =
  81          gen_device_info_timebase_scale(devinfo, result->accumulator[0]);
  82       mdapi_data->BeginTimestamp =
  83          gen_device_info_timebase_scale(devinfo, result->begin_timestamp);
  84       mdapi_data->GPUTicks = result->accumulator[1];
  85       mdapi_data->CoreFrequency = freq_end;
  86       mdapi_data->CoreFrequencyChanged = freq_end != freq_start;
  87       mdapi_data->SliceFrequency =
  88          (result->slice_frequency[0] + result->slice_frequency[1]) / 2ULL;
  89       mdapi_data->UnsliceFrequency =
  90          (result->unslice_frequency[0] + result->unslice_frequency[1]) / 2ULL;
  91       mdapi_data->SplitOccured = result->query_disjoint;
  92       return sizeof(*mdapi_data);
  93    }
  94    case 9:
  95    case 10:
  96    case 11:
  97    case 12:{
  98       struct gen9_mdapi_metrics *mdapi_data = (struct gen9_mdapi_metrics *) data;
  99
 100       if (data_size < sizeof(*mdapi_data))
 101          return 0;
 102
 103       for (int i = 0; i < ARRAY_SIZE(mdapi_data->OaCntr); i++)
 104          mdapi_data->OaCntr[i] = result->accumulator[2 + i];
 105       for (int i = 0; i < ARRAY_SIZE(mdapi_data->NoaCntr); i++) {
 106          mdapi_data->NoaCntr[i] =
 107             result->accumulator[2 + ARRAY_SIZE(mdapi_data->OaCntr) + i];
 108       }
 109
 110       mdapi_data->ReportId = result->hw_id;
 111       mdapi_data->ReportsCount = result->reports_accumulated;
 112       mdapi_data->TotalTime =
 113          gen_device_info_timebase_scale(devinfo, result->accumulator[0]);
 114       mdapi_data->BeginTimestamp =
 115          gen_device_info_timebase_scale(devinfo, result->begin_timestamp);
 116       mdapi_data->GPUTicks = result->accumulator[1];
 117       mdapi_data->CoreFrequency = freq_end;
 118       mdapi_data->CoreFrequencyChanged = freq_end != freq_start;
 119       mdapi_data->SliceFrequency =
 120          (result->slice_frequency[0] + result->slice_frequency[1]) / 2ULL;
 121       mdapi_data->UnsliceFrequency =
 122          (result->unslice_frequency[0] + result->unslice_frequency[1]) / 2ULL;
 123       mdapi_data->SplitOccured = result->query_disjoint;
 124       return sizeof(*mdapi_data);
 125    }
 126    default:
 127       unreachable("unexpected gen");
 128    }
 129 }
 130
 131 void
 132 gen_perf_register_mdapi_statistic_query(struct gen_perf_config *perf_cfg,
 133                                         const struct gen_device_info *devinfo)
 134 {
 135    if (!(devinfo->gen >= 7 && devinfo->gen <= 12))
 136       return;
 137
 138    struct gen_perf_query_info *query =
 139       gen_perf_append_query_info(perf_cfg, MAX_STAT_COUNTERS);
 140
 141    query->kind = GEN_PERF_QUERY_TYPE_PIPELINE;
 142    query->name = "Intel_Raw_Pipeline_Statistics_Query";
 143
 144    /* The order has to match mdapi_pipeline_metrics. */
 145    gen_perf_query_add_basic_stat_reg(query, IA_VERTICES_COUNT,
 146                                      "N vertices submitted");
 147    gen_perf_query_add_basic_stat_reg(query, IA_PRIMITIVES_COUNT,
 148                                      "N primitives submitted");
 149    gen_perf_query_add_basic_stat_reg(query, VS_INVOCATION_COUNT,
 150                                      "N vertex shader invocations");
 151    gen_perf_query_add_basic_stat_reg(query, GS_INVOCATION_COUNT,
 152                                      "N geometry shader invocations");
 153    gen_perf_query_add_basic_stat_reg(query, GS_PRIMITIVES_COUNT,
 154                                      "N geometry shader primitives emitted");
 155    gen_perf_query_add_basic_stat_reg(query, CL_INVOCATION_COUNT,
 156                                      "N primitives entering clipping");
 157    gen_perf_query_add_basic_stat_reg(query, CL_PRIMITIVES_COUNT,
 158                                      "N primitives leaving clipping");
 159    if (devinfo->is_haswell || devinfo->gen == 8) {
 160       gen_perf_query_add_stat_reg(query, PS_INVOCATION_COUNT, 1, 4,
 161                                   "N fragment shader invocations",
 162                                   "N fragment shader invocations");
 163    } else {
 164       gen_perf_query_add_basic_stat_reg(query, PS_INVOCATION_COUNT,
 165                                         "N fragment shader invocations");
 166    }
 167    gen_perf_query_add_basic_stat_reg(query, HS_INVOCATION_COUNT,
 168                                      "N TCS shader invocations");
 169    gen_perf_query_add_basic_stat_reg(query, DS_INVOCATION_COUNT,
 170                                      "N TES shader invocations");
 171    if (devinfo->gen >= 7) {
 172       gen_perf_query_add_basic_stat_reg(query, CS_INVOCATION_COUNT,
 173                                         "N compute shader invocations");
 174    }
 175
 176    if (devinfo->gen >= 10) {
 177       /* Reuse existing CS invocation register until we can expose this new
 178        * one.
 179        */
 180       gen_perf_query_add_basic_stat_reg(query, CS_INVOCATION_COUNT,
 181                                         "Reserved1");
 182    }
 183
 184    query->data_size = sizeof(uint64_t) * query->n_counters;
 185 }
 186
 187 static void
 188 fill_mdapi_perf_query_counter(struct gen_perf_query_info *query,
 189                               const char *name,
 190                               uint32_t data_offset,
 191                               uint32_t data_size,
 192                               enum gen_perf_counter_data_type data_type)
 193 {
 194    struct gen_perf_query_counter *counter = &query->counters[query->n_counters];
 195
 196    assert(query->n_counters <= query->max_counters);
 197
 198    counter->name = name;
 199    counter->desc = "Raw counter value";
 200    counter->type = GEN_PERF_COUNTER_TYPE_RAW;
 201    counter->data_type = data_type;
 202    counter->offset = data_offset;
 203
 204    query->n_counters++;
 205
 206    assert(counter->offset + gen_perf_query_counter_get_size(counter) <= query->data_size);
 207 }
 208
 209 #define MDAPI_QUERY_ADD_COUNTER(query, struct_name, field_name, type_name) \
 210    fill_mdapi_perf_query_counter(query, #field_name,                    \
 211                                  (uint8_t *) &struct_name.field_name -  \
 212                                  (uint8_t *) &struct_name,              \
 213                                  sizeof(struct_name.field_name),        \
 214                                  GEN_PERF_COUNTER_DATA_TYPE_##type_name)
 215 #define MDAPI_QUERY_ADD_ARRAY_COUNTER(ctx, query, struct_name, field_name, idx, type_name) \
 216    fill_mdapi_perf_query_counter(query,                                 \
 217                                  ralloc_asprintf(ctx, "%s%i", #field_name, idx), \
 218                                  (uint8_t *) &struct_name.field_name[idx] - \
 219                                  (uint8_t *) &struct_name,              \
 220                                  sizeof(struct_name.field_name[0]),     \
 221                                  GEN_PERF_COUNTER_DATA_TYPE_##type_name)
 222
 223 void
 224 gen_perf_register_mdapi_oa_query(struct gen_perf_config *perf,
 225                                  const struct gen_device_info *devinfo)
 226 {
 227    struct gen_perf_query_info *query = NULL;
 228
 229    /* MDAPI requires different structures for pretty much every generation
 230     * (right now we have definitions for gen 7 to 12).
 231     */
 232    if (!(devinfo->gen >= 7 && devinfo->gen <= 12))
 233       return;
 234
 235    switch (devinfo->gen) {
 236    case 7: {
 237       query = gen_perf_append_query_info(perf, 1 + 45 + 16 + 7);
 238       query->oa_format = I915_OA_FORMAT_A45_B8_C8;
 239
 240       struct gen7_mdapi_metrics metric_data;
 241       query->data_size = sizeof(metric_data);
 242
 243       MDAPI_QUERY_ADD_COUNTER(query, metric_data, TotalTime, UINT64);
 244       for (int i = 0; i < ARRAY_SIZE(metric_data.ACounters); i++) {
 245          MDAPI_QUERY_ADD_ARRAY_COUNTER(perf->queries, query,
 246                                        metric_data, ACounters, i, UINT64);
 247       }
 248       for (int i = 0; i < ARRAY_SIZE(metric_data.NOACounters); i++) {
 249          MDAPI_QUERY_ADD_ARRAY_COUNTER(perf->queries, query,
 250                                        metric_data, NOACounters, i, UINT64);
 251       }
 252       MDAPI_QUERY_ADD_COUNTER(query, metric_data, PerfCounter1, UINT64);
 253       MDAPI_QUERY_ADD_COUNTER(query, metric_data, PerfCounter2, UINT64);
 254       MDAPI_QUERY_ADD_COUNTER(query, metric_data, SplitOccured, BOOL32);
 255       MDAPI_QUERY_ADD_COUNTER(query, metric_data, CoreFrequencyChanged, BOOL32);
 256       MDAPI_QUERY_ADD_COUNTER(query, metric_data, CoreFrequency, UINT64);
 257       MDAPI_QUERY_ADD_COUNTER(query, metric_data, ReportId, UINT32);
 258       MDAPI_QUERY_ADD_COUNTER(query, metric_data, ReportsCount, UINT32);
 259       break;
 260    }
 261    case 8: {
 262       query = gen_perf_append_query_info(perf, 2 + 36 + 16 + 16);
 263       query->oa_format = I915_OA_FORMAT_A32u40_A4u32_B8_C8;
 264
 265       struct gen8_mdapi_metrics metric_data;
 266       query->data_size = sizeof(metric_data);
 267
 268       MDAPI_QUERY_ADD_COUNTER(query, metric_data, TotalTime, UINT64);
 269       MDAPI_QUERY_ADD_COUNTER(query, metric_data, GPUTicks, UINT64);
 270       for (int i = 0; i < ARRAY_SIZE(metric_data.OaCntr); i++) {
 271          MDAPI_QUERY_ADD_ARRAY_COUNTER(perf->queries, query,
 272                                        metric_data, OaCntr, i, UINT64);
 273       }
 274       for (int i = 0; i < ARRAY_SIZE(metric_data.NoaCntr); i++) {
 275          MDAPI_QUERY_ADD_ARRAY_COUNTER(perf->queries, query,
 276                                        metric_data, NoaCntr, i, UINT64);
 277       }
 278       MDAPI_QUERY_ADD_COUNTER(query, metric_data, BeginTimestamp, UINT64);
 279       MDAPI_QUERY_ADD_COUNTER(query, metric_data, Reserved1, UINT64);
 280       MDAPI_QUERY_ADD_COUNTER(query, metric_data, Reserved2, UINT64);
 281       MDAPI_QUERY_ADD_COUNTER(query, metric_data, Reserved3, UINT32);
 282       MDAPI_QUERY_ADD_COUNTER(query, metric_data, OverrunOccured, BOOL32);
 283       MDAPI_QUERY_ADD_COUNTER(query, metric_data, MarkerUser, UINT64);
 284       MDAPI_QUERY_ADD_COUNTER(query, metric_data, MarkerDriver, UINT64);
 285       MDAPI_QUERY_ADD_COUNTER(query, metric_data, SliceFrequency, UINT64);
 286       MDAPI_QUERY_ADD_COUNTER(query, metric_data, UnsliceFrequency, UINT64);
 287       MDAPI_QUERY_ADD_COUNTER(query, metric_data, PerfCounter1, UINT64);
 288       MDAPI_QUERY_ADD_COUNTER(query, metric_data, PerfCounter2, UINT64);
 289       MDAPI_QUERY_ADD_COUNTER(query, metric_data, SplitOccured, BOOL32);
 290       MDAPI_QUERY_ADD_COUNTER(query, metric_data, CoreFrequencyChanged, BOOL32);
 291       MDAPI_QUERY_ADD_COUNTER(query, metric_data, CoreFrequency, UINT64);
 292       MDAPI_QUERY_ADD_COUNTER(query, metric_data, ReportId, UINT32);
 293       MDAPI_QUERY_ADD_COUNTER(query, metric_data, ReportsCount, UINT32);
 294       break;
 295    }
 296    case 9:
 297    case 10:
 298    case 11:
 299    case 12: {
 300       query = gen_perf_append_query_info(perf, 2 + 36 + 16 + 16 + 16 + 2);
 301       query->oa_format = I915_OA_FORMAT_A32u40_A4u32_B8_C8;
 302
 303       struct gen9_mdapi_metrics metric_data;
 304       query->data_size = sizeof(metric_data);
 305
 306       MDAPI_QUERY_ADD_COUNTER(query, metric_data, TotalTime, UINT64);
 307       MDAPI_QUERY_ADD_COUNTER(query, metric_data, GPUTicks, UINT64);
 308       for (int i = 0; i < ARRAY_SIZE(metric_data.OaCntr); i++) {
 309          MDAPI_QUERY_ADD_ARRAY_COUNTER(perf->queries, query,
 310                                        metric_data, OaCntr, i, UINT64);
 311       }
 312       for (int i = 0; i < ARRAY_SIZE(metric_data.NoaCntr); i++) {
 313          MDAPI_QUERY_ADD_ARRAY_COUNTER(perf->queries, query,
 314                                        metric_data, NoaCntr, i, UINT64);
 315       }
 316       MDAPI_QUERY_ADD_COUNTER(query, metric_data, BeginTimestamp, UINT64);
 317       MDAPI_QUERY_ADD_COUNTER(query, metric_data, Reserved1, UINT64);
 318       MDAPI_QUERY_ADD_COUNTER(query, metric_data, Reserved2, UINT64);
 319       MDAPI_QUERY_ADD_COUNTER(query, metric_data, Reserved3, UINT32);
 320       MDAPI_QUERY_ADD_COUNTER(query, metric_data, OverrunOccured, BOOL32);
 321       MDAPI_QUERY_ADD_COUNTER(query, metric_data, MarkerUser, UINT64);
 322       MDAPI_QUERY_ADD_COUNTER(query, metric_data, MarkerDriver, UINT64);
 323       MDAPI_QUERY_ADD_COUNTER(query, metric_data, SliceFrequency, UINT64);
 324       MDAPI_QUERY_ADD_COUNTER(query, metric_data, UnsliceFrequency, UINT64);
 325       MDAPI_QUERY_ADD_COUNTER(query, metric_data, PerfCounter1, UINT64);
 326       MDAPI_QUERY_ADD_COUNTER(query, metric_data, PerfCounter2, UINT64);
 327       MDAPI_QUERY_ADD_COUNTER(query, metric_data, SplitOccured, BOOL32);
 328       MDAPI_QUERY_ADD_COUNTER(query, metric_data, CoreFrequencyChanged, BOOL32);
 329       MDAPI_QUERY_ADD_COUNTER(query, metric_data, CoreFrequency, UINT64);
 330       MDAPI_QUERY_ADD_COUNTER(query, metric_data, ReportId, UINT32);
 331       MDAPI_QUERY_ADD_COUNTER(query, metric_data, ReportsCount, UINT32);
 332       for (int i = 0; i < ARRAY_SIZE(metric_data.UserCntr); i++) {
 333          MDAPI_QUERY_ADD_ARRAY_COUNTER(perf->queries, query,
 334                                        metric_data, UserCntr, i, UINT64);
 335       }
 336       MDAPI_QUERY_ADD_COUNTER(query, metric_data, UserCntrCfgId, UINT32);
 337       MDAPI_QUERY_ADD_COUNTER(query, metric_data, Reserved4, UINT32);
 338       break;
 339    }
 340    default:
 341       unreachable("Unsupported gen");
 342       break;
 343    }
 344
 345    query->kind = GEN_PERF_QUERY_TYPE_RAW;
 346    query->name = "Intel_Raw_Hardware_Counters_Set_0_Query";
 347    query->guid = GEN_PERF_QUERY_GUID_MDAPI;
 348
 349    {
 350       /* Accumulation buffer offsets copied from an actual query... */
 351       const struct gen_perf_query_info *copy_query =
 352          &perf->queries[0];
 353
 354       query->gpu_time_offset = copy_query->gpu_time_offset;
 355       query->gpu_clock_offset = copy_query->gpu_clock_offset;
 356       query->a_offset = copy_query->a_offset;
 357       query->b_offset = copy_query->b_offset;
 358       query->c_offset = copy_query->c_offset;
 359    }
 360 }