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       fprintf(stderr, "VS Output ");
 166       brw_print_vue_map(stderr, &prog_data.base.vue_map);
 167    }
 168
 169    int st_index = -1;
 170    if (INTEL_DEBUG & DEBUG_SHADER_TIME)
 171       st_index = brw_get_shader_time_index(brw, prog, &vp->program.Base, ST_VS);
 172
 173    /* Emit GEN4 code.
 174     */
 175    char *error_str;
 176    program = brw_compile_vs(brw->intelScreen->compiler, brw, mem_ctx, key,
 177                             &prog_data, vp->program.Base.nir,
 178                             brw_select_clip_planes(&brw->ctx),
 179                             !_mesa_is_gles3(&brw->ctx),
 180                             st_index, &program_size, &error_str);
 181    if (program == NULL) {
 182       if (prog) {
 183          prog->LinkStatus = false;
 184          ralloc_strcat(&prog->InfoLog, error_str);
 185       }
 186
 187       _mesa_problem(NULL, "Failed to compile vertex shader: %s\n", error_str);
 188
 189       ralloc_free(mem_ctx);
 190       return false;
 191    }
 192
 193    if (unlikely(brw->perf_debug) && vs) {
 194       if (vs->compiled_once) {
 195          brw_vs_debug_recompile(brw, prog, key);
 196       }
 197       if (start_busy && !drm_intel_bo_busy(brw->batch.last_bo)) {
 198          perf_debug("VS compile took %.03f ms and stalled the GPU\n",
 199                     (get_time() - start_time) * 1000);
 200       }
 201       vs->compiled_once = true;
 202    }
 203
 204    /* Scratch space is used for register spilling */
 205    if (prog_data.base.base.total_scratch) {
 206       brw_get_scratch_bo(brw, &brw->vs.base.scratch_bo,
 207                          prog_data.base.base.total_scratch *
 208                          brw->max_vs_threads);
 209    }
 210
 211    brw_upload_cache(&brw->cache, BRW_CACHE_VS_PROG,
 212                     key, sizeof(struct brw_vs_prog_key),
 213                     program, program_size,
 214                     &prog_data, sizeof(prog_data),
 215                     &brw->vs.base.prog_offset, &brw->vs.prog_data);
 216    ralloc_free(mem_ctx);
 217
 218    return true;
 219 }
 220
 221 static bool
 222 key_debug(struct brw_context *brw, const char *name, int a, int b)
 223 {
 224    if (a != b) {
 225       perf_debug("  %s %d->%d\n", name, a, b);
 226       return true;
 227    }
 228    return false;
 229 }
 230
 231 void
 232 brw_vs_debug_recompile(struct brw_context *brw,
 233                        struct gl_shader_program *prog,
 234                        const struct brw_vs_prog_key *key)
 235 {
 236    struct brw_cache_item *c = NULL;
 237    const struct brw_vs_prog_key *old_key = NULL;
 238    bool found = false;
 239
 240    perf_debug("Recompiling vertex shader for program %d\n", prog->Name);
 241
 242    for (unsigned int i = 0; i < brw->cache.size; i++) {
 243       for (c = brw->cache.items[i]; c; c = c->next) {
 244          if (c->cache_id == BRW_CACHE_VS_PROG) {
 245             old_key = c->key;
 246
 247             if (old_key->program_string_id == key->program_string_id)
 248                break;
 249          }
 250       }
 251       if (c)
 252          break;
 253    }
 254
 255    if (!c) {
 256       perf_debug("  Didn't find previous compile in the shader cache for "
 257                  "debug\n");
 258       return;
 259    }
 260
 261    for (unsigned int i = 0; i < VERT_ATTRIB_MAX; i++) {
 262       found |= key_debug(brw, "Vertex attrib w/a flags",
 263                          old_key->gl_attrib_wa_flags[i],
 264                          key->gl_attrib_wa_flags[i]);
 265    }
 266
 267    found |= key_debug(brw, "legacy user clipping",
 268                       old_key->nr_userclip_plane_consts,
 269                       key->nr_userclip_plane_consts);
 270
 271    found |= key_debug(brw, "copy edgeflag",
 272                       old_key->copy_edgeflag, key->copy_edgeflag);
 273    found |= key_debug(brw, "PointCoord replace",
 274                       old_key->point_coord_replace, key->point_coord_replace);
 275    found |= key_debug(brw, "vertex color clamping",
 276                       old_key->clamp_vertex_color, key->clamp_vertex_color);
 277
 278    found |= brw_debug_recompile_sampler_key(brw, &old_key->tex, &key->tex);
 279
 280    if (!found) {
 281       perf_debug("  Something else\n");
 282    }
 283 }
 284
 285 static bool
 286 brw_vs_state_dirty(struct brw_context *brw)
 287 {
 288    return brw_state_dirty(brw,
 289                           _NEW_BUFFERS |
 290                           _NEW_LIGHT |
 291                           _NEW_POINT |
 292                           _NEW_POLYGON |
 293                           _NEW_TEXTURE |
 294                           _NEW_TRANSFORM,
 295                           BRW_NEW_VERTEX_PROGRAM |
 296                           BRW_NEW_VS_ATTRIB_WORKAROUNDS);
 297 }
 298
 299 static void
 300 brw_vs_populate_key(struct brw_context *brw,
 301                     struct brw_vs_prog_key *key)
 302 {
 303    struct gl_context *ctx = &brw->ctx;
 304    /* BRW_NEW_VERTEX_PROGRAM */
 305    struct brw_vertex_program *vp =
 306       (struct brw_vertex_program *)brw->vertex_program;
 307    struct gl_program *prog = (struct gl_program *) brw->vertex_program;
 308    int i;
 309
 310    memset(key, 0, sizeof(*key));
 311
 312    /* Just upload the program verbatim for now.  Always send it all
 313     * the inputs it asks for, whether they are varying or not.
 314     */
 315    key->program_string_id = vp->id;
 316
 317    if (ctx->Transform.ClipPlanesEnabled != 0 &&
 318        (ctx->API == API_OPENGL_COMPAT ||
 319         ctx->API == API_OPENGLES) &&
 320        vp->program.Base.ClipDistanceArraySize == 0) {
 321       key->nr_userclip_plane_consts =
 322          _mesa_logbase2(ctx->Transform.ClipPlanesEnabled) + 1;
 323    }
 324
 325    /* _NEW_POLYGON */
 326    if (brw->gen < 6) {
 327       key->copy_edgeflag = (ctx->Polygon.FrontMode != GL_FILL ||
 328                             ctx->Polygon.BackMode != GL_FILL);
 329    }
 330
 331    if (prog->OutputsWritten & (VARYING_BIT_COL0 | VARYING_BIT_COL1 |
 332                                VARYING_BIT_BFC0 | VARYING_BIT_BFC1)) {
 333       /* _NEW_LIGHT | _NEW_BUFFERS */
 334       key->clamp_vertex_color = ctx->Light._ClampVertexColor;
 335    }
 336
 337    /* _NEW_POINT */
 338    if (brw->gen < 6 && ctx->Point.PointSprite) {
 339       for (i = 0; i < 8; i++) {
 340          if (ctx->Point.CoordReplace[i])
 341             key->point_coord_replace |= (1 << i);
 342       }
 343    }
 344
 345    /* _NEW_TEXTURE */
 346    brw_populate_sampler_prog_key_data(ctx, prog, brw->vs.base.sampler_count,
 347                                       &key->tex);
 348
 349    /* BRW_NEW_VS_ATTRIB_WORKAROUNDS */
 350    memcpy(key->gl_attrib_wa_flags, brw->vb.attrib_wa_flags,
 351           sizeof(brw->vb.attrib_wa_flags));
 352 }
 353
 354 void
 355 brw_upload_vs_prog(struct brw_context *brw)
 356 {
 357    struct gl_context *ctx = &brw->ctx;
 358    struct gl_shader_program **current = ctx->_Shader->CurrentProgram;
 359    struct brw_vs_prog_key key;
 360    /* BRW_NEW_VERTEX_PROGRAM */
 361    struct brw_vertex_program *vp =
 362       (struct brw_vertex_program *)brw->vertex_program;
 363
 364    if (!brw_vs_state_dirty(brw))
 365       return;
 366
 367    brw_vs_populate_key(brw, &key);
 368
 369    if (!brw_search_cache(&brw->cache, BRW_CACHE_VS_PROG,
 370                          &key, sizeof(key),
 371                          &brw->vs.base.prog_offset, &brw->vs.prog_data)) {
 372       bool success = brw_codegen_vs_prog(brw, current[MESA_SHADER_VERTEX],
 373                                          vp, &key);
 374       (void) success;
 375       assert(success);
 376    }
 377    brw->vs.base.prog_data = &brw->vs.prog_data->base.base;
 378 }
 379
 380 bool
 381 brw_vs_precompile(struct gl_context *ctx,
 382                   struct gl_shader_program *shader_prog,
 383                   struct gl_program *prog)
 384 {
 385    struct brw_context *brw = brw_context(ctx);
 386    struct brw_vs_prog_key key;
 387    uint32_t old_prog_offset = brw->vs.base.prog_offset;
 388    struct brw_vs_prog_data *old_prog_data = brw->vs.prog_data;
 389    bool success;
 390
 391    struct gl_vertex_program *vp = (struct gl_vertex_program *) prog;
 392    struct brw_vertex_program *bvp = brw_vertex_program(vp);
 393
 394    memset(&key, 0, sizeof(key));
 395
 396    brw_setup_tex_for_precompile(brw, &key.tex, prog);
 397    key.program_string_id = bvp->id;
 398    key.clamp_vertex_color =
 399       (prog->OutputsWritten & (VARYING_BIT_COL0 | VARYING_BIT_COL1 |
 400                                VARYING_BIT_BFC0 | VARYING_BIT_BFC1));
 401
 402    success = brw_codegen_vs_prog(brw, shader_prog, bvp, &key);
 403
 404    brw->vs.base.prog_offset = old_prog_offset;
 405    brw->vs.prog_data = old_prog_data;
 406
 407    return success;
 408 }