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