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