brw_wm.c revision 877128505431adaf817dc8069172ebe4a1cdf5d8
1/* 2 Copyright (C) Intel Corp. 2006. All Rights Reserved. 3 Intel funded Tungsten Graphics to 4 develop this 3D driver. 5 6 Permission is hereby granted, free of charge, to any person obtaining 7 a copy of this software and associated documentation files (the 8 "Software"), to deal in the Software without restriction, including 9 without limitation the rights to use, copy, modify, merge, publish, 10 distribute, sublicense, and/or sell copies of the Software, and to 11 permit persons to whom the Software is furnished to do so, subject to 12 the following conditions: 13 14 The above copyright notice and this permission notice (including the 15 next paragraph) shall be included in all copies or substantial 16 portions of the Software. 17 18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 21 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE 22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 26 **********************************************************************/ 27 /* 28 * Authors: 29 * Keith Whitwell <keithw@vmware.com> 30 */ 31 32#include "brw_context.h" 33#include "brw_wm.h" 34#include "brw_state.h" 35#include "main/enums.h" 36#include "main/formats.h" 37#include "main/fbobject.h" 38#include "main/samplerobj.h" 39#include "program/prog_parameter.h" 40#include "program/program.h" 41#include "intel_mipmap_tree.h" 42 43#include "glsl/ralloc.h" 44 45/** 46 * Return a bitfield where bit n is set if barycentric interpolation mode n 47 * (see enum brw_wm_barycentric_interp_mode) is needed by the fragment shader. 48 */ 49static unsigned 50brw_compute_barycentric_interp_modes(struct brw_context *brw, 51 bool shade_model_flat, 52 const struct gl_fragment_program *fprog) 53{ 54 unsigned barycentric_interp_modes = 0; 55 int attr; 56 57 /* Loop through all fragment shader inputs to figure out what interpolation 58 * modes are in use, and set the appropriate bits in 59 * barycentric_interp_modes. 60 */ 61 for (attr = 0; attr < VARYING_SLOT_MAX; ++attr) { 62 enum glsl_interp_qualifier interp_qualifier = 63 fprog->InterpQualifier[attr]; 64 bool is_centroid = fprog->IsCentroid & BITFIELD64_BIT(attr); 65 bool is_gl_Color = attr == VARYING_SLOT_COL0 || attr == VARYING_SLOT_COL1; 66 67 /* Ignore unused inputs. */ 68 if (!(fprog->Base.InputsRead & BITFIELD64_BIT(attr))) 69 continue; 70 71 /* Ignore WPOS and FACE, because they don't require interpolation. */ 72 if (attr == VARYING_SLOT_POS || attr == VARYING_SLOT_FACE) 73 continue; 74 75 /* Determine the set (or sets) of barycentric coordinates needed to 76 * interpolate this variable. Note that when 77 * brw->needs_unlit_centroid_workaround is set, centroid interpolation 78 * uses PIXEL interpolation for unlit pixels and CENTROID interpolation 79 * for lit pixels, so we need both sets of barycentric coordinates. 80 */ 81 if (interp_qualifier == INTERP_QUALIFIER_NOPERSPECTIVE) { 82 if (is_centroid) { 83 barycentric_interp_modes |= 84 1 << BRW_WM_NONPERSPECTIVE_CENTROID_BARYCENTRIC; 85 } 86 if (!is_centroid || brw->needs_unlit_centroid_workaround) { 87 barycentric_interp_modes |= 88 1 << BRW_WM_NONPERSPECTIVE_PIXEL_BARYCENTRIC; 89 } 90 } else if (interp_qualifier == INTERP_QUALIFIER_SMOOTH || 91 (!(shade_model_flat && is_gl_Color) && 92 interp_qualifier == INTERP_QUALIFIER_NONE)) { 93 if (is_centroid) { 94 barycentric_interp_modes |= 95 1 << BRW_WM_PERSPECTIVE_CENTROID_BARYCENTRIC; 96 } 97 if (!is_centroid || brw->needs_unlit_centroid_workaround) { 98 barycentric_interp_modes |= 99 1 << BRW_WM_PERSPECTIVE_PIXEL_BARYCENTRIC; 100 } 101 } 102 } 103 104 return barycentric_interp_modes; 105} 106 107bool 108brw_wm_prog_data_compare(const void *in_a, const void *in_b) 109{ 110 const struct brw_wm_prog_data *a = in_a; 111 const struct brw_wm_prog_data *b = in_b; 112 113 /* Compare all the struct (including the base) up to the pointers. */ 114 if (memcmp(a, b, offsetof(struct brw_wm_prog_data, param))) 115 return false; 116 117 if (memcmp(a->param, b->param, a->nr_params * sizeof(void *))) 118 return false; 119 120 if (memcmp(a->pull_param, b->pull_param, a->nr_pull_params * sizeof(void *))) 121 return false; 122 123 return true; 124} 125 126void 127brw_wm_prog_data_free(const void *in_prog_data) 128{ 129 const struct brw_wm_prog_data *prog_data = in_prog_data; 130 131 ralloc_free((void *)prog_data->param); 132 ralloc_free((void *)prog_data->pull_param); 133} 134 135/** 136 * All Mesa program -> GPU code generation goes through this function. 137 * Depending on the instructions used (i.e. flow control instructions) 138 * we'll use one of two code generators. 139 */ 140bool do_wm_prog(struct brw_context *brw, 141 struct gl_shader_program *prog, 142 struct brw_fragment_program *fp, 143 struct brw_wm_prog_key *key) 144{ 145 struct brw_wm_compile *c; 146 const GLuint *program; 147 struct gl_shader *fs = NULL; 148 GLuint program_size; 149 150 if (prog) 151 fs = prog->_LinkedShaders[MESA_SHADER_FRAGMENT]; 152 153 c = rzalloc(NULL, struct brw_wm_compile); 154 155 /* Allocate the references to the uniforms that will end up in the 156 * prog_data associated with the compiled program, and which will be freed 157 * by the state cache. 158 */ 159 int param_count; 160 if (fs) { 161 param_count = fs->num_uniform_components; 162 } else { 163 param_count = fp->program.Base.Parameters->NumParameters * 4; 164 } 165 /* The backend also sometimes adds params for texture size. */ 166 param_count += 2 * BRW_MAX_TEX_UNIT; 167 c->prog_data.param = rzalloc_array(NULL, const float *, param_count); 168 c->prog_data.pull_param = rzalloc_array(NULL, const float *, param_count); 169 170 memcpy(&c->key, key, sizeof(*key)); 171 172 c->prog_data.barycentric_interp_modes = 173 brw_compute_barycentric_interp_modes(brw, c->key.flat_shade, 174 &fp->program); 175 176 program = brw_wm_fs_emit(brw, c, &fp->program, prog, &program_size); 177 if (program == NULL) 178 return false; 179 180 /* Scratch space is used for register spilling */ 181 if (c->last_scratch) { 182 perf_debug("Fragment shader triggered register spilling. " 183 "Try reducing the number of live scalar values to " 184 "improve performance.\n"); 185 186 c->prog_data.total_scratch = brw_get_scratch_size(c->last_scratch); 187 188 brw_get_scratch_bo(brw, &brw->wm.base.scratch_bo, 189 c->prog_data.total_scratch * brw->max_wm_threads); 190 } 191 192 if (unlikely(INTEL_DEBUG & DEBUG_WM)) 193 fprintf(stderr, "\n"); 194 195 brw_upload_cache(&brw->cache, BRW_WM_PROG, 196 &c->key, sizeof(c->key), 197 program, program_size, 198 &c->prog_data, sizeof(c->prog_data), 199 &brw->wm.base.prog_offset, &brw->wm.prog_data); 200 201 ralloc_free(c); 202 203 return true; 204} 205 206static bool 207key_debug(struct brw_context *brw, const char *name, int a, int b) 208{ 209 if (a != b) { 210 perf_debug(" %s %d->%d\n", name, a, b); 211 return true; 212 } else { 213 return false; 214 } 215} 216 217bool 218brw_debug_recompile_sampler_key(struct brw_context *brw, 219 const struct brw_sampler_prog_key_data *old_key, 220 const struct brw_sampler_prog_key_data *key) 221{ 222 bool found = false; 223 224 for (unsigned int i = 0; i < MAX_SAMPLERS; i++) { 225 found |= key_debug(brw, "EXT_texture_swizzle or DEPTH_TEXTURE_MODE", 226 old_key->swizzles[i], key->swizzles[i]); 227 } 228 found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 1st coordinate", 229 old_key->gl_clamp_mask[0], key->gl_clamp_mask[0]); 230 found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 2nd coordinate", 231 old_key->gl_clamp_mask[1], key->gl_clamp_mask[1]); 232 found |= key_debug(brw, "GL_CLAMP enabled on any texture unit's 3rd coordinate", 233 old_key->gl_clamp_mask[2], key->gl_clamp_mask[2]); 234 found |= key_debug(brw, "GL_MESA_ycbcr texturing\n", 235 old_key->yuvtex_mask, key->yuvtex_mask); 236 found |= key_debug(brw, "GL_MESA_ycbcr UV swapping\n", 237 old_key->yuvtex_swap_mask, key->yuvtex_swap_mask); 238 found |= key_debug(brw, "gather channel quirk on any texture unit", 239 old_key->gather_channel_quirk_mask, key->gather_channel_quirk_mask); 240 241 return found; 242} 243 244void 245brw_wm_debug_recompile(struct brw_context *brw, 246 struct gl_shader_program *prog, 247 const struct brw_wm_prog_key *key) 248{ 249 struct brw_cache_item *c = NULL; 250 const struct brw_wm_prog_key *old_key = NULL; 251 bool found = false; 252 253 perf_debug("Recompiling fragment shader for program %d\n", prog->Name); 254 255 for (unsigned int i = 0; i < brw->cache.size; i++) { 256 for (c = brw->cache.items[i]; c; c = c->next) { 257 if (c->cache_id == BRW_WM_PROG) { 258 old_key = c->key; 259 260 if (old_key->program_string_id == key->program_string_id) 261 break; 262 } 263 } 264 if (c) 265 break; 266 } 267 268 if (!c) { 269 perf_debug(" Didn't find previous compile in the shader cache for debug\n"); 270 return; 271 } 272 273 found |= key_debug(brw, "alphatest, computed depth, depth test, or " 274 "depth write", 275 old_key->iz_lookup, key->iz_lookup); 276 found |= key_debug(brw, "depth statistics", 277 old_key->stats_wm, key->stats_wm); 278 found |= key_debug(brw, "flat shading", 279 old_key->flat_shade, key->flat_shade); 280 found |= key_debug(brw, "number of color buffers", 281 old_key->nr_color_regions, key->nr_color_regions); 282 found |= key_debug(brw, "MRT alpha test or alpha-to-coverage", 283 old_key->replicate_alpha, key->replicate_alpha); 284 found |= key_debug(brw, "rendering to FBO", 285 old_key->render_to_fbo, key->render_to_fbo); 286 found |= key_debug(brw, "fragment color clamping", 287 old_key->clamp_fragment_color, key->clamp_fragment_color); 288 found |= key_debug(brw, "line smoothing", 289 old_key->line_aa, key->line_aa); 290 found |= key_debug(brw, "renderbuffer height", 291 old_key->drawable_height, key->drawable_height); 292 found |= key_debug(brw, "input slots valid", 293 old_key->input_slots_valid, key->input_slots_valid); 294 found |= key_debug(brw, "mrt alpha test function", 295 old_key->alpha_test_func, key->alpha_test_func); 296 found |= key_debug(brw, "mrt alpha test reference value", 297 old_key->alpha_test_ref, key->alpha_test_ref); 298 299 found |= brw_debug_recompile_sampler_key(brw, &old_key->tex, &key->tex); 300 301 if (!found) { 302 perf_debug(" Something else\n"); 303 } 304} 305 306void 307brw_populate_sampler_prog_key_data(struct gl_context *ctx, 308 const struct gl_program *prog, 309 unsigned sampler_count, 310 struct brw_sampler_prog_key_data *key) 311{ 312 struct brw_context *brw = brw_context(ctx); 313 314 for (int s = 0; s < sampler_count; s++) { 315 key->swizzles[s] = SWIZZLE_NOOP; 316 317 if (!(prog->SamplersUsed & (1 << s))) 318 continue; 319 320 int unit_id = prog->SamplerUnits[s]; 321 const struct gl_texture_unit *unit = &ctx->Texture.Unit[unit_id]; 322 323 if (unit->_ReallyEnabled && unit->_Current->Target != GL_TEXTURE_BUFFER) { 324 const struct gl_texture_object *t = unit->_Current; 325 const struct gl_texture_image *img = t->Image[0][t->BaseLevel]; 326 struct gl_sampler_object *sampler = _mesa_get_samplerobj(ctx, unit_id); 327 328 const bool alpha_depth = t->DepthMode == GL_ALPHA && 329 (img->_BaseFormat == GL_DEPTH_COMPONENT || 330 img->_BaseFormat == GL_DEPTH_STENCIL); 331 332 /* Haswell handles texture swizzling as surface format overrides 333 * (except for GL_ALPHA); all other platforms need MOVs in the shader. 334 */ 335 if (alpha_depth || (brw->gen < 8 && !brw->is_haswell)) 336 key->swizzles[s] = brw_get_texture_swizzle(ctx, t); 337 338 if (img->InternalFormat == GL_YCBCR_MESA) { 339 key->yuvtex_mask |= 1 << s; 340 if (img->TexFormat == MESA_FORMAT_YCBCR) 341 key->yuvtex_swap_mask |= 1 << s; 342 } 343 344 if (sampler->MinFilter != GL_NEAREST && 345 sampler->MagFilter != GL_NEAREST) { 346 if (sampler->WrapS == GL_CLAMP) 347 key->gl_clamp_mask[0] |= 1 << s; 348 if (sampler->WrapT == GL_CLAMP) 349 key->gl_clamp_mask[1] |= 1 << s; 350 if (sampler->WrapR == GL_CLAMP) 351 key->gl_clamp_mask[2] |= 1 << s; 352 } 353 354 /* gather4's channel select for green from RG32F is broken; 355 * requires a shader w/a on IVB; fixable with just SCS on HSW. */ 356 if (brw->gen == 7 && !brw->is_haswell && prog->UsesGather) { 357 if (img->InternalFormat == GL_RG32F) 358 key->gather_channel_quirk_mask |= 1 << s; 359 } 360 361 /* If this is a multisample sampler, and uses the CMS MSAA layout, 362 * then we need to emit slightly different code to first sample the 363 * MCS surface. 364 */ 365 struct intel_texture_object *intel_tex = 366 intel_texture_object((struct gl_texture_object *)t); 367 368 if (brw->gen >= 7 && 369 intel_tex->mt->msaa_layout == INTEL_MSAA_LAYOUT_CMS) { 370 key->compressed_multisample_layout_mask |= 1 << s; 371 } 372 } 373 } 374} 375 376static void brw_wm_populate_key( struct brw_context *brw, 377 struct brw_wm_prog_key *key ) 378{ 379 struct gl_context *ctx = &brw->ctx; 380 /* BRW_NEW_FRAGMENT_PROGRAM */ 381 const struct brw_fragment_program *fp = 382 (struct brw_fragment_program *)brw->fragment_program; 383 const struct gl_program *prog = (struct gl_program *) brw->fragment_program; 384 GLuint lookup = 0; 385 GLuint line_aa; 386 bool program_uses_dfdy = fp->program.UsesDFdy; 387 bool multisample_fbo = ctx->DrawBuffer->Visual.samples > 1; 388 389 memset(key, 0, sizeof(*key)); 390 391 /* Build the index for table lookup 392 */ 393 if (brw->gen < 6) { 394 /* _NEW_COLOR */ 395 if (fp->program.UsesKill || ctx->Color.AlphaEnabled) 396 lookup |= IZ_PS_KILL_ALPHATEST_BIT; 397 398 if (fp->program.Base.OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) 399 lookup |= IZ_PS_COMPUTES_DEPTH_BIT; 400 401 /* _NEW_DEPTH */ 402 if (ctx->Depth.Test) 403 lookup |= IZ_DEPTH_TEST_ENABLE_BIT; 404 405 if (ctx->Depth.Test && ctx->Depth.Mask) /* ?? */ 406 lookup |= IZ_DEPTH_WRITE_ENABLE_BIT; 407 408 /* _NEW_STENCIL | _NEW_BUFFERS */ 409 if (ctx->Stencil._Enabled) { 410 lookup |= IZ_STENCIL_TEST_ENABLE_BIT; 411 412 if (ctx->Stencil.WriteMask[0] || 413 ctx->Stencil.WriteMask[ctx->Stencil._BackFace]) 414 lookup |= IZ_STENCIL_WRITE_ENABLE_BIT; 415 } 416 key->iz_lookup = lookup; 417 } 418 419 line_aa = AA_NEVER; 420 421 /* _NEW_LINE, _NEW_POLYGON, BRW_NEW_REDUCED_PRIMITIVE */ 422 if (ctx->Line.SmoothFlag) { 423 if (brw->reduced_primitive == GL_LINES) { 424 line_aa = AA_ALWAYS; 425 } 426 else if (brw->reduced_primitive == GL_TRIANGLES) { 427 if (ctx->Polygon.FrontMode == GL_LINE) { 428 line_aa = AA_SOMETIMES; 429 430 if (ctx->Polygon.BackMode == GL_LINE || 431 (ctx->Polygon.CullFlag && 432 ctx->Polygon.CullFaceMode == GL_BACK)) 433 line_aa = AA_ALWAYS; 434 } 435 else if (ctx->Polygon.BackMode == GL_LINE) { 436 line_aa = AA_SOMETIMES; 437 438 if ((ctx->Polygon.CullFlag && 439 ctx->Polygon.CullFaceMode == GL_FRONT)) 440 line_aa = AA_ALWAYS; 441 } 442 } 443 } 444 445 key->line_aa = line_aa; 446 447 /* _NEW_HINT */ 448 if (brw->disable_derivative_optimization) { 449 key->high_quality_derivatives = 450 ctx->Hint.FragmentShaderDerivative != GL_FASTEST; 451 } else { 452 key->high_quality_derivatives = 453 ctx->Hint.FragmentShaderDerivative == GL_NICEST; 454 } 455 456 if (brw->gen < 6) 457 key->stats_wm = brw->stats_wm; 458 459 /* _NEW_LIGHT */ 460 key->flat_shade = (ctx->Light.ShadeModel == GL_FLAT); 461 462 /* _NEW_FRAG_CLAMP | _NEW_BUFFERS */ 463 key->clamp_fragment_color = ctx->Color._ClampFragmentColor; 464 465 /* _NEW_TEXTURE */ 466 brw_populate_sampler_prog_key_data(ctx, prog, brw->wm.base.sampler_count, 467 &key->tex); 468 469 /* _NEW_BUFFERS */ 470 /* 471 * Include the draw buffer origin and height so that we can calculate 472 * fragment position values relative to the bottom left of the drawable, 473 * from the incoming screen origin relative position we get as part of our 474 * payload. 475 * 476 * This is only needed for the WM_WPOSXY opcode when the fragment program 477 * uses the gl_FragCoord input. 478 * 479 * We could avoid recompiling by including this as a constant referenced by 480 * our program, but if we were to do that it would also be nice to handle 481 * getting that constant updated at batchbuffer submit time (when we 482 * hold the lock and know where the buffer really is) rather than at emit 483 * time when we don't hold the lock and are just guessing. We could also 484 * just avoid using this as key data if the program doesn't use 485 * fragment.position. 486 * 487 * For DRI2 the origin_x/y will always be (0,0) but we still need the 488 * drawable height in order to invert the Y axis. 489 */ 490 if (fp->program.Base.InputsRead & VARYING_BIT_POS) { 491 key->drawable_height = ctx->DrawBuffer->Height; 492 } 493 494 if ((fp->program.Base.InputsRead & VARYING_BIT_POS) || program_uses_dfdy) { 495 key->render_to_fbo = _mesa_is_user_fbo(ctx->DrawBuffer); 496 } 497 498 /* _NEW_BUFFERS */ 499 key->nr_color_regions = ctx->DrawBuffer->_NumColorDrawBuffers; 500 501 /* _NEW_MULTISAMPLE, _NEW_COLOR, _NEW_BUFFERS */ 502 key->replicate_alpha = ctx->DrawBuffer->_NumColorDrawBuffers > 1 && 503 (ctx->Multisample.SampleAlphaToCoverage || ctx->Color.AlphaEnabled); 504 505 /* _NEW_BUFFERS _NEW_MULTISAMPLE */ 506 key->compute_pos_offset = 507 _mesa_get_min_invocations_per_fragment(ctx, &fp->program) > 1 && 508 fp->program.Base.SystemValuesRead & SYSTEM_BIT_SAMPLE_POS; 509 510 key->compute_sample_id = 511 multisample_fbo && 512 ctx->Multisample.Enabled && 513 (fp->program.Base.SystemValuesRead & SYSTEM_BIT_SAMPLE_ID); 514 515 /* BRW_NEW_VUE_MAP_GEOM_OUT */ 516 if (brw->gen < 6 || _mesa_bitcount_64(fp->program.Base.InputsRead & 517 BRW_FS_VARYING_INPUT_MASK) > 16) 518 key->input_slots_valid = brw->vue_map_geom_out.slots_valid; 519 520 521 /* _NEW_COLOR | _NEW_BUFFERS */ 522 /* Pre-gen6, the hardware alpha test always used each render 523 * target's alpha to do alpha test, as opposed to render target 0's alpha 524 * like GL requires. Fix that by building the alpha test into the 525 * shader, and we'll skip enabling the fixed function alpha test. 526 */ 527 if (brw->gen < 6 && ctx->DrawBuffer->_NumColorDrawBuffers > 1 && ctx->Color.AlphaEnabled) { 528 key->alpha_test_func = ctx->Color.AlphaFunc; 529 key->alpha_test_ref = ctx->Color.AlphaRef; 530 } 531 532 /* The unique fragment program ID */ 533 key->program_string_id = fp->id; 534} 535 536 537static void 538brw_upload_wm_prog(struct brw_context *brw) 539{ 540 struct gl_context *ctx = &brw->ctx; 541 struct brw_wm_prog_key key; 542 struct brw_fragment_program *fp = (struct brw_fragment_program *) 543 brw->fragment_program; 544 545 brw_wm_populate_key(brw, &key); 546 547 if (!brw_search_cache(&brw->cache, BRW_WM_PROG, 548 &key, sizeof(key), 549 &brw->wm.base.prog_offset, &brw->wm.prog_data)) { 550 bool success = do_wm_prog(brw, ctx->Shader._CurrentFragmentProgram, fp, 551 &key); 552 (void) success; 553 assert(success); 554 } 555 brw->wm.base.prog_data = &brw->wm.prog_data->base; 556} 557 558 559const struct brw_tracked_state brw_wm_prog = { 560 .dirty = { 561 .mesa = (_NEW_COLOR | 562 _NEW_DEPTH | 563 _NEW_STENCIL | 564 _NEW_POLYGON | 565 _NEW_LINE | 566 _NEW_HINT | 567 _NEW_LIGHT | 568 _NEW_FRAG_CLAMP | 569 _NEW_BUFFERS | 570 _NEW_TEXTURE | 571 _NEW_MULTISAMPLE), 572 .brw = (BRW_NEW_FRAGMENT_PROGRAM | 573 BRW_NEW_REDUCED_PRIMITIVE | 574 BRW_NEW_VUE_MAP_GEOM_OUT | 575 BRW_NEW_STATS_WM) 576 }, 577 .emit = brw_upload_wm_prog 578}; 579 580