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

   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
  33 #include "main/compiler.h"
  34 #include "main/context.h"
  35 #include "brw_context.h"
  36 #include "brw_vs.h"
  37 #include "brw_util.h"
  38 #include "brw_state.h"
  39 #include "program/prog_print.h"
  40 #include "program/prog_parameter.h"
  41 #include "brw_nir.h"
  42 #include "brw_program.h"
  43
  44 #include "util/ralloc.h"
  45
  46 GLbitfield64
  47 brw_vs_outputs_written(struct brw_context *brw, struct brw_vs_prog_key *key,
  48                        GLbitfield64 user_varyings)
  49 {
  50    GLbitfield64 outputs_written = user_varyings;
  51
  52    if (key->copy_edgeflag) {
  53       outputs_written |= BITFIELD64_BIT(VARYING_SLOT_EDGE);
  54    }
  55
  56    if (brw->gen < 6) {
  57       /* Put dummy slots into the VUE for the SF to put the replaced
  58        * point sprite coords in.  We shouldn't need these dummy slots,
  59        * which take up precious URB space, but it would mean that the SF
  60        * doesn't get nice aligned pairs of input coords into output
  61        * coords, which would be a pain to handle.
  62        */
  63       for (unsigned i = 0; i < 8; i++) {
  64          if (key->point_coord_replace & (1 << i))
  65             outputs_written |= BITFIELD64_BIT(VARYING_SLOT_TEX0 + i);
  66       }
  67
  68       /* if back colors are written, allocate slots for front colors too */
  69       if (outputs_written & BITFIELD64_BIT(VARYING_SLOT_BFC0))
  70          outputs_written |= BITFIELD64_BIT(VARYING_SLOT_COL0);
  71       if (outputs_written & BITFIELD64_BIT(VARYING_SLOT_BFC1))
  72          outputs_written |= BITFIELD64_BIT(VARYING_SLOT_COL1);
  73    }
  74
  75    /* In order for legacy clipping to work, we need to populate the clip
  76     * distance varying slots whenever clipping is enabled, even if the vertex
  77     * shader doesn't write to gl_ClipDistance.
  78     */
  79    if (key->nr_userclip_plane_consts > 0) {
  80       outputs_written |= BITFIELD64_BIT(VARYING_SLOT_CLIP_DIST0);
  81       outputs_written |= BITFIELD64_BIT(VARYING_SLOT_CLIP_DIST1);
  82    }
  83
  84    return outputs_written;
  85 }
  86
  87 bool
  88 brw_codegen_vs_prog(struct brw_context *brw,
  89                     struct gl_shader_program *prog,
  90                     struct brw_vertex_program *vp,
  91                     struct brw_vs_prog_key *key)
  92 {
  93    const struct brw_compiler *compiler = brw->screen->compiler;
  94    const struct gen_device_info *devinfo = &brw->screen->devinfo;
  95    GLuint program_size;
  96    const GLuint *program;
  97    struct brw_vs_prog_data prog_data;
  98    struct brw_stage_prog_data *stage_prog_data = &prog_data.base.base;
  99    void *mem_ctx;
 100    struct brw_shader *vs = NULL;
 101    bool start_busy = false;
 102    double start_time = 0;
 103
 104    if (prog)
 105       vs = (struct brw_shader *) prog->_LinkedShaders[MESA_SHADER_VERTEX];
 106
 107    memset(&prog_data, 0, sizeof(prog_data));
 108
 109    /* Use ALT floating point mode for ARB programs so that 0^0 == 1. */
 110    if (!prog)
 111       stage_prog_data->use_alt_mode = true;
 112
 113    mem_ctx = ralloc_context(NULL);
 114
 115    brw_assign_common_binding_table_offsets(MESA_SHADER_VERTEX,
 116                                            devinfo,
 117                                            prog, &vp->program.Base,
 118                                            &prog_data.base.base, 0);
 119
 120    /* Allocate the references to the uniforms that will end up in the
 121     * prog_data associated with the compiled program, and which will be freed
 122     * by the state cache.
 123     */
 124    int param_count = vp->program.Base.nir->num_uniforms / 4;
 125
 126    if (vs)
 127       prog_data.base.base.nr_image_params = vs->base.NumImages;
 128
 129    /* vec4_visitor::setup_uniform_clipplane_values() also uploads user clip
 130     * planes as uniforms.
 131     */
 132    param_count += key->nr_userclip_plane_consts * 4;
 133
 134    stage_prog_data->param =
 135       rzalloc_array(NULL, const gl_constant_value *, param_count);
 136    stage_prog_data->pull_param =
 137       rzalloc_array(NULL, const gl_constant_value *, param_count);
 138    stage_prog_data->image_param =
 139       rzalloc_array(NULL, struct brw_image_param,
 140                     stage_prog_data->nr_image_params);
 141    stage_prog_data->nr_params = param_count;
 142
 143    if (prog) {
 144       brw_nir_setup_glsl_uniforms(vp->program.Base.nir, prog, &vp->program.Base,
 145                                   &prog_data.base.base,
 146                                   compiler->scalar_stage[MESA_SHADER_VERTEX]);
 147    } else {
 148       brw_nir_setup_arb_uniforms(vp->program.Base.nir, &vp->program.Base,
 149                                  &prog_data.base.base);
 150    }
 151
 152    uint64_t outputs_written =
 153       brw_vs_outputs_written(brw, key,
 154                              vp->program.Base.nir->info.outputs_written);
 155    prog_data.inputs_read = vp->program.Base.InputsRead;
 156
 157    if (key->copy_edgeflag) {
 158       prog_data.inputs_read |= VERT_BIT_EDGEFLAG;
 159    }
 160
 161    prog_data.base.cull_distance_mask =
 162       ((1 << vp->program.Base.CullDistanceArraySize) - 1) <<
 163       vp->program.Base.ClipDistanceArraySize;
 164
 165    brw_compute_vue_map(devinfo,
 166                        &prog_data.base.vue_map, outputs_written,
 167                        prog ? prog->SeparateShader ||
 168                               prog->_LinkedShaders[MESA_SHADER_TESS_EVAL]
 169                             : false);
 170
 171    if (0) {
 172       _mesa_fprint_program_opt(stderr, &vp->program.Base, PROG_PRINT_DEBUG,
 173                                true);
 174    }
 175
 176    if (unlikely(brw->perf_debug)) {
 177       start_busy = (brw->batch.last_bo &&
 178                     drm_intel_bo_busy(brw->batch.last_bo));
 179       start_time = get_time();
 180    }
 181
 182    if (unlikely(INTEL_DEBUG & DEBUG_VS)) {
 183       brw_dump_ir("vertex", prog, vs ? &vs->base : NULL, &vp->program.Base);
 184
 185       fprintf(stderr, "VS Output ");
 186       brw_print_vue_map(stderr, &prog_data.base.vue_map);
 187    }
 188
 189    int st_index = -1;
 190    if (INTEL_DEBUG & DEBUG_SHADER_TIME)
 191       st_index = brw_get_shader_time_index(brw, prog, &vp->program.Base, ST_VS);
 192
 193    /* Emit GEN4 code.
 194     */
 195    char *error_str;
 196    program = brw_compile_vs(compiler, brw, mem_ctx, key,
 197                             &prog_data, vp->program.Base.nir,
 198                             brw_select_clip_planes(&brw->ctx),
 199                             !_mesa_is_gles3(&brw->ctx),
 200                             st_index, &program_size, &error_str);
 201    if (program == NULL) {
 202       if (prog) {
 203          prog->LinkStatus = false;
 204          ralloc_strcat(&prog->InfoLog, error_str);
 205       }
 206
 207       _mesa_problem(NULL, "Failed to compile vertex shader: %s\n", error_str);
 208
 209       ralloc_free(mem_ctx);
 210       return false;
 211    }
 212
 213    if (unlikely(brw->perf_debug) && vs) {
 214       if (vs->compiled_once) {
 215          brw_vs_debug_recompile(brw, prog, key);
 216       }
 217       if (start_busy && !drm_intel_bo_busy(brw->batch.last_bo)) {
 218          perf_debug("VS compile took %.03f ms and stalled the GPU\n",
 219                     (get_time() - start_time) * 1000);
 220       }
 221       vs->compiled_once = true;
 222    }
 223
 224    /* Scratch space is used for register spilling */
 225    brw_alloc_stage_scratch(brw, &brw->vs.base,
 226                            prog_data.base.base.total_scratch,
 227                            devinfo->max_vs_threads);
 228
 229    brw_upload_cache(&brw->cache, BRW_CACHE_VS_PROG,
 230                     key, sizeof(struct brw_vs_prog_key),
 231                     program, program_size,
 232                     &prog_data, sizeof(prog_data),
 233                     &brw->vs.base.prog_offset, &brw->vs.base.prog_data);
 234    ralloc_free(mem_ctx);
 235
 236    return true;
 237 }
 238
 239 void
 240 brw_vs_debug_recompile(struct brw_context *brw,
 241                        struct gl_shader_program *prog,
 242                        const struct brw_vs_prog_key *key)
 243 {
 244    struct brw_cache_item *c = NULL;
 245    const struct brw_vs_prog_key *old_key = NULL;
 246    bool found = false;
 247
 248    perf_debug("Recompiling vertex shader for program %d\n", prog->Name);
 249
 250    for (unsigned int i = 0; i < brw->cache.size; i++) {
 251       for (c = brw->cache.items[i]; c; c = c->next) {
 252          if (c->cache_id == BRW_CACHE_VS_PROG) {
 253             old_key = c->key;
 254
 255             if (old_key->program_string_id == key->program_string_id)
 256                break;
 257          }
 258       }
 259       if (c)
 260          break;
 261    }
 262
 263    if (!c) {
 264       perf_debug("  Didn't find previous compile in the shader cache for "
 265                  "debug\n");
 266       return;
 267    }
 268
 269    for (unsigned int i = 0; i < VERT_ATTRIB_MAX; i++) {
 270       found |= key_debug(brw, "Vertex attrib w/a flags",
 271                          old_key->gl_attrib_wa_flags[i],
 272                          key->gl_attrib_wa_flags[i]);
 273    }
 274
 275    found |= key_debug(brw, "legacy user clipping",
 276                       old_key->nr_userclip_plane_consts,
 277                       key->nr_userclip_plane_consts);
 278
 279    found |= key_debug(brw, "copy edgeflag",
 280                       old_key->copy_edgeflag, key->copy_edgeflag);
 281    found |= key_debug(brw, "PointCoord replace",
 282                       old_key->point_coord_replace, key->point_coord_replace);
 283    found |= key_debug(brw, "vertex color clamping",
 284                       old_key->clamp_vertex_color, key->clamp_vertex_color);
 285
 286    found |= brw_debug_recompile_sampler_key(brw, &old_key->tex, &key->tex);
 287
 288    if (!found) {
 289       perf_debug("  Something else\n");
 290    }
 291 }
 292
 293 static bool
 294 brw_vs_state_dirty(const struct brw_context *brw)
 295 {
 296    return brw_state_dirty(brw,
 297                           _NEW_BUFFERS |
 298                           _NEW_LIGHT |
 299                           _NEW_POINT |
 300                           _NEW_POLYGON |
 301                           _NEW_TEXTURE |
 302                           _NEW_TRANSFORM,
 303                           BRW_NEW_VERTEX_PROGRAM |
 304                           BRW_NEW_VS_ATTRIB_WORKAROUNDS);
 305 }
 306
 307 void
 308 brw_vs_populate_key(struct brw_context *brw,
 309                     struct brw_vs_prog_key *key)
 310 {
 311    struct gl_context *ctx = &brw->ctx;
 312    /* BRW_NEW_VERTEX_PROGRAM */
 313    struct brw_vertex_program *vp =
 314       (struct brw_vertex_program *)brw->vertex_program;
 315    struct gl_program *prog = (struct gl_program *) brw->vertex_program;
 316
 317    memset(key, 0, sizeof(*key));
 318
 319    /* Just upload the program verbatim for now.  Always send it all
 320     * the inputs it asks for, whether they are varying or not.
 321     */
 322    key->program_string_id = vp->id;
 323
 324    if (ctx->Transform.ClipPlanesEnabled != 0 &&
 325        (ctx->API == API_OPENGL_COMPAT ||
 326         ctx->API == API_OPENGLES) &&
 327        vp->program.Base.ClipDistanceArraySize == 0) {
 328       key->nr_userclip_plane_consts =
 329          _mesa_logbase2(ctx->Transform.ClipPlanesEnabled) + 1;
 330    }
 331
 332    if (brw->gen < 6) {
 333       /* _NEW_POLYGON */
 334       key->copy_edgeflag = (ctx->Polygon.FrontMode != GL_FILL ||
 335                             ctx->Polygon.BackMode != GL_FILL);
 336
 337       /* _NEW_POINT */
 338       if (ctx->Point.PointSprite) {
 339          key->point_coord_replace = ctx->Point.CoordReplace & 0xff;
 340       }
 341    }
 342
 343    if (prog->nir->info.outputs_written &
 344        (VARYING_BIT_COL0 | VARYING_BIT_COL1 | VARYING_BIT_BFC0 |
 345         VARYING_BIT_BFC1)) {
 346       /* _NEW_LIGHT | _NEW_BUFFERS */
 347       key->clamp_vertex_color = ctx->Light._ClampVertexColor;
 348    }
 349
 350    /* _NEW_TEXTURE */
 351    brw_populate_sampler_prog_key_data(ctx, prog, &key->tex);
 352
 353    /* BRW_NEW_VS_ATTRIB_WORKAROUNDS */
 354    if (brw->gen < 8 && !brw->is_haswell) {
 355       memcpy(key->gl_attrib_wa_flags, brw->vb.attrib_wa_flags,
 356              sizeof(brw->vb.attrib_wa_flags));
 357    }
 358 }
 359
 360 void
 361 brw_upload_vs_prog(struct brw_context *brw)
 362 {
 363    struct gl_context *ctx = &brw->ctx;
 364    struct gl_shader_program **current = ctx->_Shader->CurrentProgram;
 365    struct brw_vs_prog_key key;
 366    /* BRW_NEW_VERTEX_PROGRAM */
 367    struct brw_vertex_program *vp =
 368       (struct brw_vertex_program *)brw->vertex_program;
 369
 370    if (!brw_vs_state_dirty(brw))
 371       return;
 372
 373    brw_vs_populate_key(brw, &key);
 374
 375    if (!brw_search_cache(&brw->cache, BRW_CACHE_VS_PROG,
 376                          &key, sizeof(key),
 377                          &brw->vs.base.prog_offset, &brw->vs.base.prog_data)) {
 378       bool success = brw_codegen_vs_prog(brw, current[MESA_SHADER_VERTEX],
 379                                          vp, &key);
 380       (void) success;
 381       assert(success);
 382    }
 383 }
 384
 385 bool
 386 brw_vs_precompile(struct gl_context *ctx,
 387                   struct gl_shader_program *shader_prog,
 388                   struct gl_program *prog)
 389 {
 390    struct brw_context *brw = brw_context(ctx);
 391    struct brw_vs_prog_key key;
 392    uint32_t old_prog_offset = brw->vs.base.prog_offset;
 393    struct brw_stage_prog_data *old_prog_data = brw->vs.base.prog_data;
 394    bool success;
 395
 396    struct gl_vertex_program *vp = (struct gl_vertex_program *) prog;
 397    struct brw_vertex_program *bvp = brw_vertex_program(vp);
 398
 399    memset(&key, 0, sizeof(key));
 400
 401    brw_setup_tex_for_precompile(brw, &key.tex, prog);
 402    key.program_string_id = bvp->id;
 403    key.clamp_vertex_color =
 404       (prog->nir->info.outputs_written &
 405        (VARYING_BIT_COL0 | VARYING_BIT_COL1 | VARYING_BIT_BFC0 |
 406         VARYING_BIT_BFC1));
 407
 408    success = brw_codegen_vs_prog(brw, shader_prog, bvp, &key);
 409
 410    brw->vs.base.prog_offset = old_prog_offset;
 411    brw->vs.base.prog_data = old_prog_data;
 412
 413    return success;
 414 }