brw_queryobj.c revision 7540f25a345ed8d35d97ba4fbf66227a281eff6a
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 * 26 */ 27 28/** @file brw_queryobj.c 29 * 30 * Support for query objects (GL_ARB_occlusion_query, GL_ARB_timer_query, 31 * GL_EXT_transform_feedback, and friends). 32 * 33 * The hardware provides a PIPE_CONTROL command that can report the number of 34 * fragments that passed the depth test, or the hardware timer. They are 35 * appropriately synced with the stage of the pipeline for our extensions' 36 * needs. 37 * 38 * To avoid getting samples from another context's rendering in our results, 39 * we capture the counts at the start and end of every batchbuffer while the 40 * query is active, and sum up the differences. (We should do so for 41 * GL_TIME_ELAPSED as well, but don't). 42 */ 43#include "main/imports.h" 44 45#include "brw_context.h" 46#include "brw_defines.h" 47#include "brw_state.h" 48#include "intel_batchbuffer.h" 49#include "intel_reg.h" 50 51static void 52write_timestamp(struct intel_context *intel, drm_intel_bo *query_bo, int idx) 53{ 54 if (intel->gen >= 6) { 55 /* Emit workaround flushes: */ 56 if (intel->gen == 6) { 57 /* The timestamp write below is a non-zero post-sync op, which on 58 * Gen6 necessitates a CS stall. CS stalls need stall at scoreboard 59 * set. See the comments for intel_emit_post_sync_nonzero_flush(). 60 */ 61 BEGIN_BATCH(4); 62 OUT_BATCH(_3DSTATE_PIPE_CONTROL | (4 - 2)); 63 OUT_BATCH(PIPE_CONTROL_CS_STALL | PIPE_CONTROL_STALL_AT_SCOREBOARD); 64 OUT_BATCH(0); 65 OUT_BATCH(0); 66 ADVANCE_BATCH(); 67 } 68 69 BEGIN_BATCH(5); 70 OUT_BATCH(_3DSTATE_PIPE_CONTROL | (5 - 2)); 71 OUT_BATCH(PIPE_CONTROL_WRITE_TIMESTAMP); 72 OUT_RELOC(query_bo, 73 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION, 74 PIPE_CONTROL_GLOBAL_GTT_WRITE | 75 idx * sizeof(uint64_t)); 76 OUT_BATCH(0); 77 OUT_BATCH(0); 78 ADVANCE_BATCH(); 79 } else { 80 BEGIN_BATCH(4); 81 OUT_BATCH(_3DSTATE_PIPE_CONTROL | (4 - 2) | 82 PIPE_CONTROL_WRITE_TIMESTAMP); 83 OUT_RELOC(query_bo, 84 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION, 85 PIPE_CONTROL_GLOBAL_GTT_WRITE | 86 idx * sizeof(uint64_t)); 87 OUT_BATCH(0); 88 OUT_BATCH(0); 89 ADVANCE_BATCH(); 90 } 91} 92 93static void 94write_depth_count(struct intel_context *intel, drm_intel_bo *query_bo, int idx) 95{ 96 if (intel->gen >= 6) { 97 /* Emit Sandybridge workaround flush: */ 98 if (intel->gen == 6) 99 intel_emit_post_sync_nonzero_flush(intel); 100 101 BEGIN_BATCH(5); 102 OUT_BATCH(_3DSTATE_PIPE_CONTROL | (5 - 2)); 103 OUT_BATCH(PIPE_CONTROL_DEPTH_STALL | 104 PIPE_CONTROL_WRITE_DEPTH_COUNT); 105 OUT_RELOC(query_bo, 106 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION, 107 PIPE_CONTROL_GLOBAL_GTT_WRITE | 108 (idx * sizeof(uint64_t))); 109 OUT_BATCH(0); 110 OUT_BATCH(0); 111 ADVANCE_BATCH(); 112 } else { 113 BEGIN_BATCH(4); 114 OUT_BATCH(_3DSTATE_PIPE_CONTROL | (4 - 2) | 115 PIPE_CONTROL_DEPTH_STALL | 116 PIPE_CONTROL_WRITE_DEPTH_COUNT); 117 /* This object could be mapped cacheable, but we don't have an exposed 118 * mechanism to support that. Since it's going uncached, tell GEM that 119 * we're writing to it. The usual clflush should be all that's required 120 * to pick up the results. 121 */ 122 OUT_RELOC(query_bo, 123 I915_GEM_DOMAIN_INSTRUCTION, I915_GEM_DOMAIN_INSTRUCTION, 124 PIPE_CONTROL_GLOBAL_GTT_WRITE | 125 (idx * sizeof(uint64_t))); 126 OUT_BATCH(0); 127 OUT_BATCH(0); 128 ADVANCE_BATCH(); 129 } 130} 131 132/** Waits on the query object's BO and totals the results for this query */ 133static void 134brw_queryobj_get_results(struct gl_context *ctx, 135 struct brw_query_object *query) 136{ 137 struct intel_context *intel = intel_context(ctx); 138 139 int i; 140 uint64_t *results; 141 142 if (query->bo == NULL) 143 return; 144 145 if (unlikely(INTEL_DEBUG & DEBUG_PERF)) { 146 if (drm_intel_bo_busy(query->bo)) { 147 perf_debug("Stalling on the GPU waiting for a query object.\n"); 148 } 149 } 150 151 drm_intel_bo_map(query->bo, false); 152 results = query->bo->virtual; 153 switch (query->Base.Target) { 154 case GL_TIME_ELAPSED_EXT: 155 if (intel->gen >= 6) 156 query->Base.Result += 80 * (results[1] - results[0]); 157 else 158 query->Base.Result += 1000 * ((results[1] >> 32) - (results[0] >> 32)); 159 break; 160 161 case GL_TIMESTAMP: 162 if (intel->gen >= 6) { 163 /* Our timer is a clock that increments every 80ns (regardless of 164 * other clock scaling in the system). The timestamp register we can 165 * read for glGetTimestamp() masks out the top 32 bits, so we do that 166 * here too to let the two counters be compared against each other. 167 * 168 * If we just multiplied that 32 bits of data by 80, it would roll 169 * over at a non-power-of-two, so an application couldn't use 170 * GL_QUERY_COUNTER_BITS to handle rollover correctly. Instead, we 171 * report 36 bits and truncate at that (rolling over 5 times as often 172 * as the HW counter), and when the 32-bit counter rolls over, it 173 * happens to also be at a rollover in the reported value from near 174 * (1<<36) to 0. 175 * 176 * The low 32 bits rolls over in ~343 seconds. Our 36-bit result 177 * rolls over every ~69 seconds. 178 */ 179 query->Base.Result = 80 * (results[1] & 0xffffffff); 180 query->Base.Result &= (1ull << 36) - 1; 181 } else { 182 query->Base.Result = 1000 * (results[1] >> 32); 183 } 184 185 break; 186 187 case GL_SAMPLES_PASSED_ARB: 188 /* Map and count the pixels from the current query BO */ 189 for (i = query->first_index; i <= query->last_index; i++) { 190 query->Base.Result += results[i * 2 + 1] - results[i * 2]; 191 } 192 break; 193 194 case GL_PRIMITIVES_GENERATED: 195 case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 196 /* We don't actually query the hardware for this value, so query->bo 197 * should always be NULL and execution should never reach here. 198 */ 199 assert(!"Unreachable"); 200 break; 201 202 default: 203 assert(!"Unrecognized query target in brw_queryobj_get_results()"); 204 break; 205 } 206 drm_intel_bo_unmap(query->bo); 207 208 drm_intel_bo_unreference(query->bo); 209 query->bo = NULL; 210} 211 212static struct gl_query_object * 213brw_new_query_object(struct gl_context *ctx, GLuint id) 214{ 215 struct brw_query_object *query; 216 217 query = calloc(1, sizeof(struct brw_query_object)); 218 219 query->Base.Id = id; 220 query->Base.Result = 0; 221 query->Base.Active = false; 222 query->Base.Ready = true; 223 224 return &query->Base; 225} 226 227static void 228brw_delete_query(struct gl_context *ctx, struct gl_query_object *q) 229{ 230 struct brw_query_object *query = (struct brw_query_object *)q; 231 232 drm_intel_bo_unreference(query->bo); 233 free(query); 234} 235 236static void 237brw_begin_query(struct gl_context *ctx, struct gl_query_object *q) 238{ 239 struct brw_context *brw = brw_context(ctx); 240 struct intel_context *intel = intel_context(ctx); 241 struct brw_query_object *query = (struct brw_query_object *)q; 242 243 switch (query->Base.Target) { 244 case GL_TIME_ELAPSED_EXT: 245 drm_intel_bo_unreference(query->bo); 246 query->bo = drm_intel_bo_alloc(intel->bufmgr, "timer query", 4096, 4096); 247 write_timestamp(intel, query->bo, 0); 248 break; 249 250 case GL_SAMPLES_PASSED_ARB: 251 /* Reset our driver's tracking of query state. */ 252 drm_intel_bo_unreference(query->bo); 253 query->bo = NULL; 254 query->first_index = -1; 255 query->last_index = -1; 256 257 brw->query.obj = query; 258 intel->stats_wm++; 259 break; 260 261 case GL_PRIMITIVES_GENERATED: 262 /* We don't actually query the hardware for this value; we keep track of 263 * it a software counter. So just reset the counter. 264 */ 265 brw->sol.primitives_generated = 0; 266 brw->sol.counting_primitives_generated = true; 267 break; 268 269 case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 270 /* We don't actually query the hardware for this value; we keep track of 271 * it a software counter. So just reset the counter. 272 */ 273 brw->sol.primitives_written = 0; 274 brw->sol.counting_primitives_written = true; 275 break; 276 277 default: 278 assert(!"Unrecognized query target in brw_begin_query()"); 279 break; 280 } 281} 282 283/** 284 * Begin the ARB_occlusion_query query on a query object. 285 */ 286static void 287brw_end_query(struct gl_context *ctx, struct gl_query_object *q) 288{ 289 struct brw_context *brw = brw_context(ctx); 290 struct intel_context *intel = intel_context(ctx); 291 struct brw_query_object *query = (struct brw_query_object *)q; 292 293 switch (query->Base.Target) { 294 case GL_TIMESTAMP: 295 drm_intel_bo_unreference(query->bo); 296 query->bo = drm_intel_bo_alloc(intel->bufmgr, "timer query", 297 4096, 4096); 298 /* FALLTHROUGH */ 299 300 case GL_TIME_ELAPSED_EXT: 301 write_timestamp(intel, query->bo, 1); 302 intel_batchbuffer_flush(intel); 303 break; 304 305 case GL_SAMPLES_PASSED_ARB: 306 /* Flush the batchbuffer in case it has writes to our query BO. 307 * Have later queries write to a new query BO so that further rendering 308 * doesn't delay the collection of our results. 309 */ 310 if (query->bo) { 311 brw_emit_query_end(brw); 312 intel_batchbuffer_flush(intel); 313 314 drm_intel_bo_unreference(brw->query.bo); 315 brw->query.bo = NULL; 316 } 317 318 brw->query.obj = NULL; 319 320 intel->stats_wm--; 321 break; 322 323 case GL_PRIMITIVES_GENERATED: 324 /* We don't actually query the hardware for this value; we keep track of 325 * it in a software counter. So just read the counter and store it in 326 * the query object. 327 */ 328 query->Base.Result = brw->sol.primitives_generated; 329 brw->sol.counting_primitives_generated = false; 330 331 /* And set brw->query.obj to NULL so that this query won't try to wait 332 * for any rendering to complete. 333 */ 334 query->bo = NULL; 335 break; 336 337 case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: 338 /* We don't actually query the hardware for this value; we keep track of 339 * it in a software counter. So just read the counter and store it in 340 * the query object. 341 */ 342 query->Base.Result = brw->sol.primitives_written; 343 brw->sol.counting_primitives_written = false; 344 345 /* And set brw->query.obj to NULL so that this query won't try to wait 346 * for any rendering to complete. 347 */ 348 query->bo = NULL; 349 break; 350 351 default: 352 assert(!"Unrecognized query target in brw_end_query()"); 353 break; 354 } 355} 356 357static void brw_wait_query(struct gl_context *ctx, struct gl_query_object *q) 358{ 359 struct brw_query_object *query = (struct brw_query_object *)q; 360 361 brw_queryobj_get_results(ctx, query); 362 query->Base.Ready = true; 363} 364 365static void brw_check_query(struct gl_context *ctx, struct gl_query_object *q) 366{ 367 struct brw_query_object *query = (struct brw_query_object *)q; 368 369 if (query->bo == NULL || !drm_intel_bo_busy(query->bo)) { 370 brw_queryobj_get_results(ctx, query); 371 query->Base.Ready = true; 372 } 373} 374 375/** Called to set up the query BO and account for its aperture space */ 376void 377brw_prepare_query_begin(struct brw_context *brw) 378{ 379 struct intel_context *intel = &brw->intel; 380 381 /* Skip if we're not doing any queries. */ 382 if (!brw->query.obj) 383 return; 384 385 /* Get a new query BO if we're going to need it. */ 386 if (brw->query.bo == NULL || 387 brw->query.index * 2 + 1 >= 4096 / sizeof(uint64_t)) { 388 drm_intel_bo_unreference(brw->query.bo); 389 brw->query.bo = NULL; 390 391 brw->query.bo = drm_intel_bo_alloc(intel->bufmgr, "query", 4096, 1); 392 393 /* clear target buffer */ 394 drm_intel_bo_map(brw->query.bo, true); 395 memset((char *)brw->query.bo->virtual, 0, 4096); 396 drm_intel_bo_unmap(brw->query.bo); 397 398 brw->query.index = 0; 399 } 400} 401 402/** Called just before primitive drawing to get a beginning PS_DEPTH_COUNT. */ 403void 404brw_emit_query_begin(struct brw_context *brw) 405{ 406 struct intel_context *intel = &brw->intel; 407 struct gl_context *ctx = &intel->ctx; 408 struct brw_query_object *query = brw->query.obj; 409 410 /* Skip if we're not doing any queries, or we've emitted the start. */ 411 if (!query || brw->query.active) 412 return; 413 414 write_depth_count(intel, brw->query.bo, brw->query.index * 2); 415 416 if (query->bo != brw->query.bo) { 417 if (query->bo != NULL) 418 brw_queryobj_get_results(ctx, query); 419 drm_intel_bo_reference(brw->query.bo); 420 query->bo = brw->query.bo; 421 query->first_index = brw->query.index; 422 } 423 query->last_index = brw->query.index; 424 brw->query.active = true; 425} 426 427/** Called at batchbuffer flush to get an ending PS_DEPTH_COUNT */ 428void 429brw_emit_query_end(struct brw_context *brw) 430{ 431 struct intel_context *intel = &brw->intel; 432 433 if (!brw->query.active) 434 return; 435 436 write_depth_count(intel, brw->query.bo, brw->query.index * 2 + 1); 437 438 brw->query.active = false; 439 brw->query.index++; 440} 441 442static uint64_t 443brw_get_timestamp(struct gl_context *ctx) 444{ 445 struct intel_context *intel = intel_context(ctx); 446 uint64_t result = 0; 447 448 drm_intel_reg_read(intel->bufmgr, TIMESTAMP, &result); 449 450 /* See logic in brw_queryobj_get_results() */ 451 result = result >> 32; 452 result *= 80; 453 result &= (1ull << 36) - 1; 454 455 return result; 456} 457 458void brw_init_queryobj_functions(struct dd_function_table *functions) 459{ 460 functions->NewQueryObject = brw_new_query_object; 461 functions->DeleteQuery = brw_delete_query; 462 functions->BeginQuery = brw_begin_query; 463 functions->EndQuery = brw_end_query; 464 functions->CheckQuery = brw_check_query; 465 functions->WaitQuery = brw_wait_query; 466 functions->GetTimestamp = brw_get_timestamp; 467} 468