src/mesa/drivers/dri/i965/gen6_queryobj.c

   1 /*
   2  * Copyright © 2008 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  * Authors:
  24  *    Eric Anholt <eric@anholt.net>
  25  *    Kenneth Graunke <kenneth@whitecape.org>
  26  */
  27
  28 /** @file gen6_queryobj.c
  29  *
  30  * Support for query objects (GL_ARB_occlusion_query, GL_ARB_timer_query,
  31  * GL_EXT_transform_feedback, and friends) on platforms that support
  32  * hardware contexts (Gen6+).
  33  */
  34 #include "main/imports.h"
  35
  36 #include "brw_context.h"
  37 #include "brw_defines.h"
  38 #include "brw_state.h"
  39 #include "intel_batchbuffer.h"
  40 #include "intel_reg.h"
  41
  42 /*
  43  * Write an arbitrary 64-bit register to a buffer via MI_STORE_REGISTER_MEM.
  44  *
  45  * Only TIMESTAMP and PS_DEPTH_COUNT have special PIPE_CONTROL support; other
  46  * counters have to be read via the generic MI_STORE_REGISTER_MEM.
  47  *
  48  * Callers must explicitly flush the pipeline to ensure the desired value is
  49  * available.
  50  */
  51 void
  52 brw_store_register_mem64(struct brw_context *brw,
  53                          drm_intel_bo *bo, uint32_t reg, int idx)
  54 {
  55    assert(brw->gen >= 6);
  56
  57    /* MI_STORE_REGISTER_MEM only stores a single 32-bit value, so to
  58     * read a full 64-bit register, we need to do two of them.
  59     */
  60    if (brw->gen >= 8) {
  61       BEGIN_BATCH(8);
  62       OUT_BATCH(MI_STORE_REGISTER_MEM | (4 - 2));
  63       OUT_BATCH(reg);
  64       OUT_RELOC64(bo, I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
  65                   idx * sizeof(uint64_t));
  66       OUT_BATCH(MI_STORE_REGISTER_MEM | (4 - 2));
  67       OUT_BATCH(reg + sizeof(uint32_t));
  68       OUT_RELOC64(bo, I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
  69                   sizeof(uint32_t) + idx * sizeof(uint64_t));
  70       ADVANCE_BATCH();
  71    } else {
  72       BEGIN_BATCH(6);
  73       OUT_BATCH(MI_STORE_REGISTER_MEM | (3 - 2));
  74       OUT_BATCH(reg);
  75       OUT_RELOC(bo, I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
  76                 idx * sizeof(uint64_t));
  77       OUT_BATCH(MI_STORE_REGISTER_MEM | (3 - 2));
  78       OUT_BATCH(reg + sizeof(uint32_t));
  79       OUT_RELOC(bo, I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION,
  80                 sizeof(uint32_t) + idx * sizeof(uint64_t));
  81       ADVANCE_BATCH();
  82    }
  83 }
  84
  85 static void
  86 write_primitives_generated(struct brw_context *brw,
  87                            drm_intel_bo *query_bo, int stream, int idx)
  88 {
  89    intel_batchbuffer_emit_mi_flush(brw);
  90
  91    if (brw->gen >= 7) {
  92       brw_store_register_mem64(brw, query_bo,
  93                                GEN7_SO_PRIM_STORAGE_NEEDED(stream), idx);
  94    } else {
  95       brw_store_register_mem64(brw, query_bo, CL_INVOCATION_COUNT, idx);
  96    }
  97 }
  98
  99 static void
 100 write_xfb_primitives_written(struct brw_context *brw,
 101                              drm_intel_bo *bo, int stream, int idx)
 102 {
 103    intel_batchbuffer_emit_mi_flush(brw);
 104
 105    if (brw->gen >= 7) {
 106       brw_store_register_mem64(brw, bo, GEN7_SO_NUM_PRIMS_WRITTEN(stream), idx);
 107    } else {
 108       brw_store_register_mem64(brw, bo, GEN6_SO_NUM_PRIMS_WRITTEN, idx);
 109    }
 110 }
 111
 112 /**
 113  * Wait on the query object's BO and calculate the final result.
 114  */
 115 static void
 116 gen6_queryobj_get_results(struct gl_context *ctx,
 117                           struct brw_query_object *query)
 118 {
 119    struct brw_context *brw = brw_context(ctx);
 120
 121    if (query->bo == NULL)
 122       return;
 123
 124    /* If the application has requested the query result, but this batch is
 125     * still contributing to it, flush it now so the results will be present
 126     * when mapped.
 127     */
 128    if (drm_intel_bo_references(brw->batch.bo, query->bo))
 129       intel_batchbuffer_flush(brw);
 130
 131    if (unlikely(brw->perf_debug)) {
 132       if (drm_intel_bo_busy(query->bo)) {
 133          perf_debug("Stalling on the GPU waiting for a query object.\n");
 134       }
 135    }
 136
 137    drm_intel_bo_map(query->bo, false);
 138    uint64_t *results = query->bo->virtual;
 139    switch (query->Base.Target) {
 140    case GL_TIME_ELAPSED:
 141       /* The query BO contains the starting and ending timestamps.
 142        * Subtract the two and convert to nanoseconds.
 143        */
 144       query->Base.Result += 80 * (results[1] - results[0]);
 145       break;
 146
 147    case GL_TIMESTAMP:
 148       /* Our timer is a clock that increments every 80ns (regardless of
 149        * other clock scaling in the system).  The timestamp register we can
 150        * read for glGetTimestamp() masks out the top 32 bits, so we do that
 151        * here too to let the two counters be compared against each other.
 152        *
 153        * If we just multiplied that 32 bits of data by 80, it would roll
 154        * over at a non-power-of-two, so an application couldn't use
 155        * GL_QUERY_COUNTER_BITS to handle rollover correctly.  Instead, we
 156        * report 36 bits and truncate at that (rolling over 5 times as often
 157        * as the HW counter), and when the 32-bit counter rolls over, it
 158        * happens to also be at a rollover in the reported value from near
 159        * (1<<36) to 0.
 160        *
 161        * The low 32 bits rolls over in ~343 seconds.  Our 36-bit result
 162        * rolls over every ~69 seconds.
 163        *
 164        * The query BO contains a single timestamp value in results[0].
 165        */
 166       query->Base.Result = 80 * (results[0] & 0xffffffff);
 167       query->Base.Result &= (1ull << 36) - 1;
 168       break;
 169
 170    case GL_SAMPLES_PASSED_ARB:
 171       /* We need to use += rather than = here since some BLT-based operations
 172        * may have added additional samples to our occlusion query value.
 173        */
 174       query->Base.Result += results[1] - results[0];
 175       break;
 176
 177    case GL_ANY_SAMPLES_PASSED:
 178    case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
 179       if (results[0] != results[1])
 180          query->Base.Result = true;
 181       break;
 182
 183    case GL_PRIMITIVES_GENERATED:
 184    case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
 185       query->Base.Result = results[1] - results[0];
 186       break;
 187
 188    default:
 189       assert(!"Unrecognized query target in brw_queryobj_get_results()");
 190       break;
 191    }
 192    drm_intel_bo_unmap(query->bo);
 193
 194    /* Now that we've processed the data stored in the query's buffer object,
 195     * we can release it.
 196     */
 197    drm_intel_bo_unreference(query->bo);
 198    query->bo = NULL;
 199 }
 200
 201 /**
 202  * Driver hook for glBeginQuery().
 203  *
 204  * Initializes driver structures and emits any GPU commands required to begin
 205  * recording data for the query.
 206  */
 207 static void
 208 gen6_begin_query(struct gl_context *ctx, struct gl_query_object *q)
 209 {
 210    struct brw_context *brw = brw_context(ctx);
 211    struct brw_query_object *query = (struct brw_query_object *)q;
 212
 213    /* Since we're starting a new query, we need to throw away old results. */
 214    drm_intel_bo_unreference(query->bo);
 215    query->bo = drm_intel_bo_alloc(brw->bufmgr, "query results", 4096, 4096);
 216
 217    switch (query->Base.Target) {
 218    case GL_TIME_ELAPSED:
 219       /* For timestamp queries, we record the starting time right away so that
 220        * we measure the full time between BeginQuery and EndQuery.  There's
 221        * some debate about whether this is the right thing to do.  Our decision
 222        * is based on the following text from the ARB_timer_query extension:
 223        *
 224        * "(5) Should the extension measure total time elapsed between the full
 225        *      completion of the BeginQuery and EndQuery commands, or just time
 226        *      spent in the graphics library?
 227        *
 228        *  RESOLVED:  This extension will measure the total time elapsed
 229        *  between the full completion of these commands.  Future extensions
 230        *  may implement a query to determine time elapsed at different stages
 231        *  of the graphics pipeline."
 232        *
 233        * We write a starting timestamp now (at index 0).  At EndQuery() time,
 234        * we'll write a second timestamp (at index 1), and subtract the two to
 235        * obtain the time elapsed.  Notably, this includes time elapsed while
 236        * the system was doing other work, such as running other applications.
 237        */
 238       brw_write_timestamp(brw, query->bo, 0);
 239       break;
 240
 241    case GL_ANY_SAMPLES_PASSED:
 242    case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
 243    case GL_SAMPLES_PASSED_ARB:
 244       brw_write_depth_count(brw, query->bo, 0);
 245       break;
 246
 247    case GL_PRIMITIVES_GENERATED:
 248       write_primitives_generated(brw, query->bo, query->Base.Stream, 0);
 249       break;
 250
 251    case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
 252       write_xfb_primitives_written(brw, query->bo, query->Base.Stream, 0);
 253       break;
 254
 255    default:
 256       assert(!"Unrecognized query target in brw_begin_query()");
 257       break;
 258    }
 259 }
 260
 261 /**
 262  * Driver hook for glEndQuery().
 263  *
 264  * Emits GPU commands to record a final query value, ending any data capturing.
 265  * However, the final result isn't necessarily available until the GPU processes
 266  * those commands.  brw_queryobj_get_results() processes the captured data to
 267  * produce the final result.
 268  */
 269 static void
 270 gen6_end_query(struct gl_context *ctx, struct gl_query_object *q)
 271 {
 272    struct brw_context *brw = brw_context(ctx);
 273    struct brw_query_object *query = (struct brw_query_object *)q;
 274
 275    switch (query->Base.Target) {
 276    case GL_TIME_ELAPSED:
 277       brw_write_timestamp(brw, query->bo, 1);
 278       break;
 279
 280    case GL_ANY_SAMPLES_PASSED:
 281    case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
 282    case GL_SAMPLES_PASSED_ARB:
 283       brw_write_depth_count(brw, query->bo, 1);
 284       break;
 285
 286    case GL_PRIMITIVES_GENERATED:
 287       write_primitives_generated(brw, query->bo, query->Base.Stream, 1);
 288       break;
 289
 290    case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
 291       write_xfb_primitives_written(brw, query->bo, query->Base.Stream, 1);
 292       break;
 293
 294    default:
 295       assert(!"Unrecognized query target in brw_end_query()");
 296       break;
 297    }
 298 }
 299
 300 /**
 301  * The WaitQuery() driver hook.
 302  *
 303  * Wait for a query result to become available and return it.  This is the
 304  * backing for glGetQueryObjectiv() with the GL_QUERY_RESULT pname.
 305  */
 306 static void gen6_wait_query(struct gl_context *ctx, struct gl_query_object *q)
 307 {
 308    struct brw_query_object *query = (struct brw_query_object *)q;
 309
 310    gen6_queryobj_get_results(ctx, query);
 311    query->Base.Ready = true;
 312 }
 313
 314 /**
 315  * The CheckQuery() driver hook.
 316  *
 317  * Checks whether a query result is ready yet.  If not, flushes.
 318  * This is the backing for glGetQueryObjectiv()'s QUERY_RESULT_AVAILABLE pname.
 319  */
 320 static void gen6_check_query(struct gl_context *ctx, struct gl_query_object *q)
 321 {
 322    struct brw_context *brw = brw_context(ctx);
 323    struct brw_query_object *query = (struct brw_query_object *)q;
 324
 325    /* From the GL_ARB_occlusion_query spec:
 326     *
 327     *     "Instead of allowing for an infinite loop, performing a
 328     *      QUERY_RESULT_AVAILABLE_ARB will perform a flush if the result is
 329     *      not ready yet on the first time it is queried.  This ensures that
 330     *      the async query will return true in finite time.
 331     */
 332    if (query->bo && drm_intel_bo_references(brw->batch.bo, query->bo))
 333       intel_batchbuffer_flush(brw);
 334
 335    if (query->bo == NULL || !drm_intel_bo_busy(query->bo)) {
 336       gen6_queryobj_get_results(ctx, query);
 337       query->Base.Ready = true;
 338    }
 339 }
 340
 341 /* Initialize Gen6+-specific query object functions. */
 342 void gen6_init_queryobj_functions(struct dd_function_table *functions)
 343 {
 344    functions->BeginQuery = gen6_begin_query;
 345    functions->EndQuery = gen6_end_query;
 346    functions->CheckQuery = gen6_check_query;
 347    functions->WaitQuery = gen6_wait_query;
 348 }