src/mesa/main/performance_monitor.c

   1 /*
   2  * Copyright © 2012 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
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /**
  25  * \file performance_monitor.c
  26  * Core Mesa support for the AMD_performance_monitor extension.
  27  *
  28  * In order to implement this extension, start by defining two enums:
  29  * one for Groups, and one for Counters.  These will be used as indexes into
  30  * arrays, so they should start at 0 and increment from there.
  31  *
  32  * Counter IDs need to be globally unique.  That is, you can't have counter 7
  33  * in group A and counter 7 in group B.  A global enum of all available
  34  * counters is a convenient way to guarantee this.
  35  */
  36
  37 #include <stdbool.h>
  38 #include "glheader.h"
  39 #include "context.h"
  40 #include "enums.h"
  41 #include "hash.h"
  42 #include "macros.h"
  43 #include "mtypes.h"
  44 #include "performance_monitor.h"
  45 #include "util/bitset.h"
  46 #include "util/ralloc.h"
  47
  48 void
  49 _mesa_init_performance_monitors(struct gl_context *ctx)
  50 {
  51    ctx->PerfMonitor.Monitors = _mesa_NewHashTable();
  52    ctx->PerfMonitor.NumGroups = 0;
  53    ctx->PerfMonitor.Groups = NULL;
  54 }
  55
  56 static inline void
  57 init_groups(struct gl_context *ctx)
  58 {
  59    if (unlikely(!ctx->PerfMonitor.Groups))
  60       ctx->Driver.InitPerfMonitorGroups(ctx);
  61 }
  62
  63 static struct gl_perf_monitor_object *
  64 new_performance_monitor(struct gl_context *ctx, GLuint index)
  65 {
  66    unsigned i;
  67    struct gl_perf_monitor_object *m = ctx->Driver.NewPerfMonitor(ctx);
  68
  69    if (m == NULL)
  70       return NULL;
  71
  72    m->Name = index;
  73
  74    m->Active = false;
  75
  76    m->ActiveGroups =
  77       rzalloc_array(NULL, unsigned, ctx->PerfMonitor.NumGroups);
  78
  79    m->ActiveCounters =
  80       ralloc_array(NULL, BITSET_WORD *, ctx->PerfMonitor.NumGroups);
  81
  82    if (m->ActiveGroups == NULL || m->ActiveCounters == NULL)
  83       goto fail;
  84
  85    for (i = 0; i < ctx->PerfMonitor.NumGroups; i++) {
  86       const struct gl_perf_monitor_group *g = &ctx->PerfMonitor.Groups[i];
  87
  88       m->ActiveCounters[i] = rzalloc_array(m->ActiveCounters, BITSET_WORD,
  89                                            BITSET_WORDS(g->NumCounters));
  90       if (m->ActiveCounters[i] == NULL)
  91          goto fail;
  92    }
  93
  94    return m;
  95
  96 fail:
  97    ralloc_free(m->ActiveGroups);
  98    ralloc_free(m->ActiveCounters);
  99    ctx->Driver.DeletePerfMonitor(ctx, m);
 100    return NULL;
 101 }
 102
 103 static void
 104 free_performance_monitor(GLuint key, void *data, void *user)
 105 {
 106    struct gl_perf_monitor_object *m = data;
 107    struct gl_context *ctx = user;
 108
 109    ralloc_free(m->ActiveGroups);
 110    ralloc_free(m->ActiveCounters);
 111    ctx->Driver.DeletePerfMonitor(ctx, m);
 112 }
 113
 114 void
 115 _mesa_free_performance_monitors(struct gl_context *ctx)
 116 {
 117    _mesa_HashDeleteAll(ctx->PerfMonitor.Monitors,
 118                        free_performance_monitor, ctx);
 119    _mesa_DeleteHashTable(ctx->PerfMonitor.Monitors);
 120 }
 121
 122 static inline struct gl_perf_monitor_object *
 123 lookup_monitor(struct gl_context *ctx, GLuint id)
 124 {
 125    return (struct gl_perf_monitor_object *)
 126       _mesa_HashLookup(ctx->PerfMonitor.Monitors, id);
 127 }
 128
 129 static inline const struct gl_perf_monitor_group *
 130 get_group(const struct gl_context *ctx, GLuint id)
 131 {
 132    if (id >= ctx->PerfMonitor.NumGroups)
 133       return NULL;
 134
 135    return &ctx->PerfMonitor.Groups[id];
 136 }
 137
 138 static inline const struct gl_perf_monitor_counter *
 139 get_counter(const struct gl_perf_monitor_group *group_obj, GLuint id)
 140 {
 141    if (id >= group_obj->NumCounters)
 142       return NULL;
 143
 144    return &group_obj->Counters[id];
 145 }
 146
 147 /* For INTEL_performance_query, query id 0 is reserved to be invalid. We use
 148  * index to Groups array + 1 as the query id. Same applies to counter id.
 149  */
 150 static inline GLuint
 151 queryid_to_index(GLuint queryid)
 152 {
 153    return queryid - 1;
 154 }
 155
 156 static inline GLuint
 157 index_to_queryid(GLuint index)
 158 {
 159    return index + 1;
 160 }
 161
 162 static inline bool
 163 queryid_valid(const struct gl_context *ctx, GLuint queryid)
 164 {
 165    return get_group(ctx, queryid_to_index(queryid)) != NULL;
 166 }
 167
 168 static inline GLuint
 169 counterid_to_index(GLuint counterid)
 170 {
 171    return counterid - 1;
 172 }
 173
 174 /*****************************************************************************/
 175
 176 void GLAPIENTRY
 177 _mesa_GetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize,
 178                               GLuint *groups)
 179 {
 180    GET_CURRENT_CONTEXT(ctx);
 181    init_groups(ctx);
 182
 183    if (numGroups != NULL)
 184       *numGroups = ctx->PerfMonitor.NumGroups;
 185
 186    if (groupsSize > 0 && groups != NULL) {
 187       unsigned i;
 188       unsigned n = MIN2((GLuint) groupsSize, ctx->PerfMonitor.NumGroups);
 189
 190       /* We just use the index in the Groups array as the ID. */
 191       for (i = 0; i < n; i++)
 192          groups[i] = i;
 193    }
 194 }
 195
 196 void GLAPIENTRY
 197 _mesa_GetPerfMonitorCountersAMD(GLuint group, GLint *numCounters,
 198                                 GLint *maxActiveCounters,
 199                                 GLsizei countersSize, GLuint *counters)
 200 {
 201    GET_CURRENT_CONTEXT(ctx);
 202    const struct gl_perf_monitor_group *group_obj;
 203
 204    init_groups(ctx);
 205
 206    group_obj = get_group(ctx, group);
 207    if (group_obj == NULL) {
 208       _mesa_error(ctx, GL_INVALID_VALUE,
 209                   "glGetPerfMonitorCountersAMD(invalid group)");
 210       return;
 211    }
 212
 213    if (maxActiveCounters != NULL)
 214       *maxActiveCounters = group_obj->MaxActiveCounters;
 215
 216    if (numCounters != NULL)
 217       *numCounters = group_obj->NumCounters;
 218
 219    if (counters != NULL) {
 220       unsigned i;
 221       unsigned n = MIN2(group_obj->NumCounters, (GLuint) countersSize);
 222       for (i = 0; i < n; i++) {
 223          /* We just use the index in the Counters array as the ID. */
 224          counters[i] = i;
 225       }
 226    }
 227 }
 228
 229 void GLAPIENTRY
 230 _mesa_GetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize,
 231                                    GLsizei *length, GLchar *groupString)
 232 {
 233    GET_CURRENT_CONTEXT(ctx);
 234    const struct gl_perf_monitor_group *group_obj;
 235
 236    init_groups(ctx);
 237
 238    group_obj = get_group(ctx, group);
 239    if (group_obj == NULL) {
 240       _mesa_error(ctx, GL_INVALID_VALUE, "glGetPerfMonitorGroupStringAMD");
 241       return;
 242    }
 243
 244    if (bufSize == 0) {
 245       /* Return the number of characters that would be required to hold the
 246        * group string, excluding the null terminator.
 247        */
 248       if (length != NULL)
 249          *length = strlen(group_obj->Name);
 250    } else {
 251       if (length != NULL)
 252          *length = MIN2(strlen(group_obj->Name), bufSize);
 253       if (groupString != NULL)
 254          strncpy(groupString, group_obj->Name, bufSize);
 255    }
 256 }
 257
 258 void GLAPIENTRY
 259 _mesa_GetPerfMonitorCounterStringAMD(GLuint group, GLuint counter,
 260                                      GLsizei bufSize, GLsizei *length,
 261                                      GLchar *counterString)
 262 {
 263    GET_CURRENT_CONTEXT(ctx);
 264
 265    const struct gl_perf_monitor_group *group_obj;
 266    const struct gl_perf_monitor_counter *counter_obj;
 267
 268    init_groups(ctx);
 269
 270    group_obj = get_group(ctx, group);
 271
 272    if (group_obj == NULL) {
 273       _mesa_error(ctx, GL_INVALID_VALUE,
 274                   "glGetPerfMonitorCounterStringAMD(invalid group)");
 275       return;
 276    }
 277
 278    counter_obj = get_counter(group_obj, counter);
 279
 280    if (counter_obj == NULL) {
 281       _mesa_error(ctx, GL_INVALID_VALUE,
 282                   "glGetPerfMonitorCounterStringAMD(invalid counter)");
 283       return;
 284    }
 285
 286    if (bufSize == 0) {
 287       /* Return the number of characters that would be required to hold the
 288        * counter string, excluding the null terminator.
 289        */
 290       if (length != NULL)
 291          *length = strlen(counter_obj->Name);
 292    } else {
 293       if (length != NULL)
 294          *length = MIN2(strlen(counter_obj->Name), bufSize);
 295       if (counterString != NULL)
 296          strncpy(counterString, counter_obj->Name, bufSize);
 297    }
 298 }
 299
 300 void GLAPIENTRY
 301 _mesa_GetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname,
 302                                    GLvoid *data)
 303 {
 304    GET_CURRENT_CONTEXT(ctx);
 305
 306    const struct gl_perf_monitor_group *group_obj;
 307    const struct gl_perf_monitor_counter *counter_obj;
 308
 309    init_groups(ctx);
 310
 311    group_obj = get_group(ctx, group);
 312
 313    if (group_obj == NULL) {
 314       _mesa_error(ctx, GL_INVALID_VALUE,
 315                   "glGetPerfMonitorCounterInfoAMD(invalid group)");
 316       return;
 317    }
 318
 319    counter_obj = get_counter(group_obj, counter);
 320
 321    if (counter_obj == NULL) {
 322       _mesa_error(ctx, GL_INVALID_VALUE,
 323                   "glGetPerfMonitorCounterInfoAMD(invalid counter)");
 324       return;
 325    }
 326
 327    switch (pname) {
 328    case GL_COUNTER_TYPE_AMD:
 329       *((GLenum *) data) = counter_obj->Type;
 330       break;
 331
 332    case GL_COUNTER_RANGE_AMD:
 333       switch (counter_obj->Type) {
 334       case GL_FLOAT:
 335       case GL_PERCENTAGE_AMD: {
 336          float *f_data = data;
 337          f_data[0] = counter_obj->Minimum.f;
 338          f_data[1] = counter_obj->Maximum.f;
 339          break;
 340       }
 341       case GL_UNSIGNED_INT: {
 342          uint32_t *u32_data = data;
 343          u32_data[0] = counter_obj->Minimum.u32;
 344          u32_data[1] = counter_obj->Maximum.u32;
 345          break;
 346       }
 347       case GL_UNSIGNED_INT64_AMD: {
 348          uint64_t *u64_data = data;
 349          u64_data[0] = counter_obj->Minimum.u64;
 350          u64_data[1] = counter_obj->Maximum.u64;
 351          break;
 352       }
 353       default:
 354          assert(!"Should not get here: invalid counter type");
 355       }
 356       break;
 357
 358    default:
 359       _mesa_error(ctx, GL_INVALID_ENUM,
 360                   "glGetPerfMonitorCounterInfoAMD(pname)");
 361       return;
 362    }
 363 }
 364
 365 void GLAPIENTRY
 366 _mesa_GenPerfMonitorsAMD(GLsizei n, GLuint *monitors)
 367 {
 368    GLuint first;
 369    GET_CURRENT_CONTEXT(ctx);
 370
 371    if (MESA_VERBOSE & VERBOSE_API)
 372       _mesa_debug(ctx, "glGenPerfMonitorsAMD(%d)\n", n);
 373
 374    init_groups(ctx);
 375
 376    if (n < 0) {
 377       _mesa_error(ctx, GL_INVALID_VALUE, "glGenPerfMonitorsAMD(n < 0)");
 378       return;
 379    }
 380
 381    if (monitors == NULL)
 382       return;
 383
 384    /* We don't actually need them to be contiguous, but this is what
 385     * the rest of Mesa does, so we may as well.
 386     */
 387    first = _mesa_HashFindFreeKeyBlock(ctx->PerfMonitor.Monitors, n);
 388    if (first) {
 389       GLsizei i;
 390       for (i = 0; i < n; i++) {
 391          struct gl_perf_monitor_object *m =
 392             new_performance_monitor(ctx, first + i);
 393          if (!m) {
 394             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenPerfMonitorsAMD");
 395             return;
 396          }
 397          monitors[i] = first + i;
 398          _mesa_HashInsert(ctx->PerfMonitor.Monitors, first + i, m);
 399       }
 400    } else {
 401       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenPerfMonitorsAMD");
 402       return;
 403    }
 404 }
 405
 406 void GLAPIENTRY
 407 _mesa_DeletePerfMonitorsAMD(GLsizei n, GLuint *monitors)
 408 {
 409    GLint i;
 410    GET_CURRENT_CONTEXT(ctx);
 411
 412    if (MESA_VERBOSE & VERBOSE_API)
 413       _mesa_debug(ctx, "glDeletePerfMonitorsAMD(%d)\n", n);
 414
 415    if (n < 0) {
 416       _mesa_error(ctx, GL_INVALID_VALUE, "glDeletePerfMonitorsAMD(n < 0)");
 417       return;
 418    }
 419
 420    if (monitors == NULL)
 421       return;
 422
 423    for (i = 0; i < n; i++) {
 424       struct gl_perf_monitor_object *m = lookup_monitor(ctx, monitors[i]);
 425
 426       if (m) {
 427          /* Give the driver a chance to stop the monitor if it's active. */
 428          if (m->Active) {
 429             ctx->Driver.ResetPerfMonitor(ctx, m);
 430             m->Ended = false;
 431          }
 432
 433          _mesa_HashRemove(ctx->PerfMonitor.Monitors, monitors[i]);
 434          ralloc_free(m->ActiveGroups);
 435          ralloc_free(m->ActiveCounters);
 436          ctx->Driver.DeletePerfMonitor(ctx, m);
 437       } else {
 438          /* "INVALID_VALUE error will be generated if any of the monitor IDs
 439           *  in the <monitors> parameter to DeletePerfMonitorsAMD do not
 440           *  reference a valid generated monitor ID."
 441           */
 442          _mesa_error(ctx, GL_INVALID_VALUE,
 443                      "glDeletePerfMonitorsAMD(invalid monitor)");
 444       }
 445    }
 446 }
 447
 448 void GLAPIENTRY
 449 _mesa_SelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable,
 450                                    GLuint group, GLint numCounters,
 451                                    GLuint *counterList)
 452 {
 453    GET_CURRENT_CONTEXT(ctx);
 454    int i;
 455    struct gl_perf_monitor_object *m;
 456    const struct gl_perf_monitor_group *group_obj;
 457
 458    m = lookup_monitor(ctx, monitor);
 459
 460    /* "INVALID_VALUE error will be generated if the <monitor> parameter to
 461     *  SelectPerfMonitorCountersAMD does not reference a monitor created by
 462     *  GenPerfMonitorsAMD."
 463     */
 464    if (m == NULL) {
 465       _mesa_error(ctx, GL_INVALID_VALUE,
 466                   "glSelectPerfMonitorCountersAMD(invalid monitor)");
 467       return;
 468    }
 469
 470    group_obj = get_group(ctx, group);
 471
 472    /* "INVALID_VALUE error will be generated if the <group> parameter to
 473     *  GetPerfMonitorCountersAMD, GetPerfMonitorCounterStringAMD,
 474     *  GetPerfMonitorCounterStringAMD, GetPerfMonitorCounterInfoAMD, or
 475     *  SelectPerfMonitorCountersAMD does not reference a valid group ID."
 476     */
 477    if (group_obj == NULL) {
 478       _mesa_error(ctx, GL_INVALID_VALUE,
 479                   "glSelectPerfMonitorCountersAMD(invalid group)");
 480       return;
 481    }
 482
 483    /* "INVALID_VALUE error will be generated if the <numCounters> parameter to
 484     *  SelectPerfMonitorCountersAMD is less than 0."
 485     */
 486    if (numCounters < 0) {
 487       _mesa_error(ctx, GL_INVALID_VALUE,
 488                   "glSelectPerfMonitorCountersAMD(numCounters < 0)");
 489       return;
 490    }
 491
 492    /* "When SelectPerfMonitorCountersAMD is called on a monitor, any outstanding
 493     *  results for that monitor become invalidated and the result queries
 494     *  PERFMON_RESULT_SIZE_AMD and PERFMON_RESULT_AVAILABLE_AMD are reset to 0."
 495     */
 496    ctx->Driver.ResetPerfMonitor(ctx, m);
 497
 498    /* Sanity check the counter ID list. */
 499    for (i = 0; i < numCounters; i++) {
 500       if (counterList[i] >= group_obj->NumCounters) {
 501          _mesa_error(ctx, GL_INVALID_VALUE,
 502                      "glSelectPerfMonitorCountersAMD(invalid counter ID)");
 503          return;
 504       }
 505    }
 506
 507    if (enable) {
 508       /* Enable the counters */
 509       for (i = 0; i < numCounters; i++) {
 510          ++m->ActiveGroups[group];
 511          BITSET_SET(m->ActiveCounters[group], counterList[i]);
 512       }
 513    } else {
 514       /* Disable the counters */
 515       for (i = 0; i < numCounters; i++) {
 516          --m->ActiveGroups[group];
 517          BITSET_CLEAR(m->ActiveCounters[group], counterList[i]);
 518       }
 519    }
 520 }
 521
 522 void GLAPIENTRY
 523 _mesa_BeginPerfMonitorAMD(GLuint monitor)
 524 {
 525    GET_CURRENT_CONTEXT(ctx);
 526
 527    struct gl_perf_monitor_object *m = lookup_monitor(ctx, monitor);
 528
 529    if (m == NULL) {
 530       _mesa_error(ctx, GL_INVALID_VALUE,
 531                   "glBeginPerfMonitorAMD(invalid monitor)");
 532       return;
 533    }
 534
 535    /* "INVALID_OPERATION error will be generated if BeginPerfMonitorAMD is
 536     *  called when a performance monitor is already active."
 537     */
 538    if (m->Active) {
 539       _mesa_error(ctx, GL_INVALID_OPERATION,
 540                   "glBeginPerfMonitor(already active)");
 541       return;
 542    }
 543
 544    /* The driver is free to return false if it can't begin monitoring for
 545     * any reason.  This translates into an INVALID_OPERATION error.
 546     */
 547    if (ctx->Driver.BeginPerfMonitor(ctx, m)) {
 548       m->Active = true;
 549       m->Ended = false;
 550    } else {
 551       _mesa_error(ctx, GL_INVALID_OPERATION,
 552                   "glBeginPerfMonitor(driver unable to begin monitoring)");
 553    }
 554 }
 555
 556 void GLAPIENTRY
 557 _mesa_EndPerfMonitorAMD(GLuint monitor)
 558 {
 559    GET_CURRENT_CONTEXT(ctx);
 560
 561    struct gl_perf_monitor_object *m = lookup_monitor(ctx, monitor);
 562
 563    if (m == NULL) {
 564       _mesa_error(ctx, GL_INVALID_VALUE, "glEndPerfMonitorAMD(invalid monitor)");
 565       return;
 566    }
 567
 568    /* "INVALID_OPERATION error will be generated if EndPerfMonitorAMD is called
 569     *  when a performance monitor is not currently started."
 570     */
 571    if (!m->Active) {
 572       _mesa_error(ctx, GL_INVALID_OPERATION, "glBeginPerfMonitor(not active)");
 573       return;
 574    }
 575
 576    ctx->Driver.EndPerfMonitor(ctx, m);
 577
 578    m->Active = false;
 579    m->Ended = true;
 580 }
 581
 582 /**
 583  * Return the number of bytes needed to store a monitor's result.
 584  */
 585 static unsigned
 586 perf_monitor_result_size(const struct gl_context *ctx,
 587                          const struct gl_perf_monitor_object *m)
 588 {
 589    unsigned group, counter;
 590    unsigned size = 0;
 591
 592    for (group = 0; group < ctx->PerfMonitor.NumGroups; group++) {
 593       const struct gl_perf_monitor_group *g = &ctx->PerfMonitor.Groups[group];
 594       BITSET_WORD tmp;
 595
 596       BITSET_FOREACH_SET(counter, tmp, m->ActiveCounters[group], g->NumCounters) {
 597          const struct gl_perf_monitor_counter *c = &g->Counters[counter];
 598
 599          size += sizeof(uint32_t); /* Group ID */
 600          size += sizeof(uint32_t); /* Counter ID */
 601          size += _mesa_perf_monitor_counter_size(c);
 602       }
 603    }
 604    return size;
 605 }
 606
 607 void GLAPIENTRY
 608 _mesa_GetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname,
 609                                    GLsizei dataSize, GLuint *data,
 610                                    GLint *bytesWritten)
 611 {
 612    GET_CURRENT_CONTEXT(ctx);
 613
 614    struct gl_perf_monitor_object *m = lookup_monitor(ctx, monitor);
 615    bool result_available;
 616
 617    if (m == NULL) {
 618       _mesa_error(ctx, GL_INVALID_VALUE,
 619                   "glGetPerfMonitorCounterDataAMD(invalid monitor)");
 620       return;
 621    }
 622
 623    /* "It is an INVALID_OPERATION error for <data> to be NULL." */
 624    if (data == NULL) {
 625       _mesa_error(ctx, GL_INVALID_OPERATION,
 626                   "glGetPerfMonitorCounterDataAMD(data == NULL)");
 627       return;
 628    }
 629
 630    /* We need at least enough room for a single value. */
 631    if (dataSize < sizeof(GLuint)) {
 632       if (bytesWritten != NULL)
 633          *bytesWritten = 0;
 634       return;
 635    }
 636
 637    /* If the monitor has never ended, there is no result. */
 638    result_available = m->Ended &&
 639       ctx->Driver.IsPerfMonitorResultAvailable(ctx, m);
 640
 641    /* AMD appears to return 0 for all queries unless a result is available. */
 642    if (!result_available) {
 643       *data = 0;
 644       if (bytesWritten != NULL)
 645          *bytesWritten = sizeof(GLuint);
 646       return;
 647    }
 648
 649    switch (pname) {
 650    case GL_PERFMON_RESULT_AVAILABLE_AMD:
 651       *data = 1;
 652       if (bytesWritten != NULL)
 653          *bytesWritten = sizeof(GLuint);
 654       break;
 655    case GL_PERFMON_RESULT_SIZE_AMD:
 656       *data = perf_monitor_result_size(ctx, m);
 657       if (bytesWritten != NULL)
 658          *bytesWritten = sizeof(GLuint);
 659       break;
 660    case GL_PERFMON_RESULT_AMD:
 661       ctx->Driver.GetPerfMonitorResult(ctx, m, dataSize, data, bytesWritten);
 662       break;
 663    default:
 664       _mesa_error(ctx, GL_INVALID_ENUM,
 665                   "glGetPerfMonitorCounterDataAMD(pname)");
 666    }
 667 }
 668
 669 /**
 670  * Returns how many bytes a counter's value takes up.
 671  */
 672 unsigned
 673 _mesa_perf_monitor_counter_size(const struct gl_perf_monitor_counter *c)
 674 {
 675    switch (c->Type) {
 676    case GL_FLOAT:
 677    case GL_PERCENTAGE_AMD:
 678       return sizeof(GLfloat);
 679    case GL_UNSIGNED_INT:
 680       return sizeof(GLuint);
 681    case GL_UNSIGNED_INT64_AMD:
 682       return sizeof(uint64_t);
 683    default:
 684       assert(!"Should not get here: invalid counter type");
 685       return 0;
 686    }
 687 }