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