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_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    bool start_busy = false;
 101    double start_time = 0;
 102
 103    memset(&prog_data, 0, sizeof(prog_data));
 104
 105    /* Use ALT floating point mode for ARB programs so that 0^0 == 1. */
 106    if (!prog)
 107       stage_prog_data->use_alt_mode = true;
 108
 109    mem_ctx = ralloc_context(NULL);
 110
 111    brw_assign_common_binding_table_offsets(MESA_SHADER_VERTEX, devinfo, prog,
 112                                            &vp->program, &prog_data.base.base,
 113                                            0);
 114
 115    /* Allocate the references to the uniforms that will end up in the
 116     * prog_data associated with the compiled program, and which will be freed
 117     * by the state cache.
 118     */
 119    int param_count = vp->program.nir->num_uniforms / 4;
 120
 121    prog_data.base.base.nr_image_params = vp->program.info.num_images;
 122
 123    /* vec4_visitor::setup_uniform_clipplane_values() also uploads user clip
 124     * planes as uniforms.
 125     */
 126    param_count += key->nr_userclip_plane_consts * 4;
 127
 128    stage_prog_data->param =
 129       rzalloc_array(NULL, const gl_constant_value *, param_count);
 130    stage_prog_data->pull_param =
 131       rzalloc_array(NULL, const gl_constant_value *, param_count);
 132    stage_prog_data->image_param =
 133       rzalloc_array(NULL, struct brw_image_param,
 134                     stage_prog_data->nr_image_params);
 135    stage_prog_data->nr_params = param_count;
 136
 137    if (prog) {
 138       brw_nir_setup_glsl_uniforms(vp->program.nir, prog, &vp->program,
 139                                   &prog_data.base.base,
 140                                   compiler->scalar_stage[MESA_SHADER_VERTEX]);
 141    } else {
 142       brw_nir_setup_arb_uniforms(vp->program.nir, &vp->program,
 143                                  &prog_data.base.base);
 144    }
 145
 146    uint64_t outputs_written =
 147       brw_vs_outputs_written(brw, key, vp->program.info.outputs_written);
 148    prog_data.inputs_read = vp->program.info.inputs_read;
 149    prog_data.double_inputs_read = vp->program.info.double_inputs_read;
 150
 151    if (key->copy_edgeflag) {
 152       prog_data.inputs_read |= VERT_BIT_EDGEFLAG;
 153    }
 154
 155    brw_compute_vue_map(devinfo,
 156                        &prog_data.base.vue_map, outputs_written,
 157                        vp->program.nir->info->separate_shader);
 158
 159    if (0) {
 160       _mesa_fprint_program_opt(stderr, &vp->program, PROG_PRINT_DEBUG, true);
 161    }
 162
 163    if (unlikely(brw->perf_debug)) {
 164       start_busy = (brw->batch.last_bo &&
 165                     drm_intel_bo_busy(brw->batch.last_bo));
 166       start_time = get_time();
 167    }
 168
 169    if (unlikely(INTEL_DEBUG & DEBUG_VS)) {
 170       if (!prog)
 171          brw_dump_arb_asm("vertex", &vp->program);
 172
 173       fprintf(stderr, "VS Output ");
 174       brw_print_vue_map(stderr, &prog_data.base.vue_map);
 175    }
 176
 177    int st_index = -1;
 178    if (INTEL_DEBUG & DEBUG_SHADER_TIME) {
 179       bool is_glsl_sh = prog != NULL;
 180       st_index = brw_get_shader_time_index(brw, &vp->program, ST_VS,
 181                                            is_glsl_sh);
 182    }
 183
 184    /* Emit GEN4 code.
 185     */
 186    char *error_str;
 187    program = brw_compile_vs(compiler, brw, mem_ctx, key, &prog_data,
 188                             vp->program.nir,
 189                             brw_select_clip_planes(&brw->ctx),
 190                             !_mesa_is_gles3(&brw->ctx),
 191                             st_index, &program_size, &error_str);
 192    if (program == NULL) {
 193       if (prog) {
 194          vp->program.sh.data->LinkStatus = false;
 195          ralloc_strcat(&vp->program.sh.data->InfoLog, error_str);
 196       }
 197
 198       _mesa_problem(NULL, "Failed to compile vertex shader: %s\n", error_str);
 199
 200       ralloc_free(mem_ctx);
 201       return false;
 202    }
 203
 204    if (unlikely(brw->perf_debug)) {
 205       if (vp->compiled_once) {
 206          brw_vs_debug_recompile(brw, prog, key);
 207       }
 208       if (start_busy && !drm_intel_bo_busy(brw->batch.last_bo)) {
 209          perf_debug("VS compile took %.03f ms and stalled the GPU\n",
 210                     (get_time() - start_time) * 1000);
 211       }
 212       vp->compiled_once = true;
 213    }
 214
 215    /* Scratch space is used for register spilling */
 216    brw_alloc_stage_scratch(brw, &brw->vs.base,
 217                            prog_data.base.base.total_scratch,
 218                            devinfo->max_vs_threads);
 219
 220    brw_upload_cache(&brw->cache, BRW_CACHE_VS_PROG,
 221                     key, sizeof(struct brw_vs_prog_key),
 222                     program, program_size,
 223                     &prog_data, sizeof(prog_data),
 224                     &brw->vs.base.prog_offset, &brw->vs.base.prog_data);
 225    ralloc_free(mem_ctx);
 226
 227    return true;
 228 }
 229
 230 void
 231 brw_vs_debug_recompile(struct brw_context *brw,
 232                        struct gl_shader_program *prog,
 233                        const struct brw_vs_prog_key *key)
 234 {
 235    struct brw_cache_item *c = NULL;
 236    const struct brw_vs_prog_key *old_key = NULL;
 237    bool found = false;
 238
 239    perf_debug("Recompiling vertex shader for program %d\n", prog->Name);
 240
 241    for (unsigned int i = 0; i < brw->cache.size; i++) {
 242       for (c = brw->cache.items[i]; c; c = c->next) {
 243          if (c->cache_id == BRW_CACHE_VS_PROG) {
 244             old_key = c->key;
 245
 246             if (old_key->program_string_id == key->program_string_id)
 247                break;
 248          }
 249       }
 250       if (c)
 251          break;
 252    }
 253
 254    if (!c) {
 255       perf_debug("  Didn't find previous compile in the shader cache for "
 256                  "debug\n");
 257       return;
 258    }
 259
 260    for (unsigned int i = 0; i < VERT_ATTRIB_MAX; i++) {
 261       found |= key_debug(brw, "Vertex attrib w/a flags",
 262                          old_key->gl_attrib_wa_flags[i],
 263                          key->gl_attrib_wa_flags[i]);
 264    }
 265
 266    found |= key_debug(brw, "legacy user clipping",
 267                       old_key->nr_userclip_plane_consts,
 268                       key->nr_userclip_plane_consts);
 269
 270    found |= key_debug(brw, "copy edgeflag",
 271                       old_key->copy_edgeflag, key->copy_edgeflag);
 272    found |= key_debug(brw, "PointCoord replace",
 273                       old_key->point_coord_replace, key->point_coord_replace);
 274    found |= key_debug(brw, "vertex color clamping",
 275                       old_key->clamp_vertex_color, key->clamp_vertex_color);
 276
 277    found |= brw_debug_recompile_sampler_key(brw, &old_key->tex, &key->tex);
 278
 279    if (!found) {
 280       perf_debug("  Something else\n");
 281    }
 282 }
 283
 284 static bool
 285 brw_vs_state_dirty(const struct brw_context *brw)
 286 {
 287    return brw_state_dirty(brw,
 288                           _NEW_BUFFERS |
 289                           _NEW_LIGHT |
 290                           _NEW_POINT |
 291                           _NEW_POLYGON |
 292                           _NEW_TEXTURE |
 293                           _NEW_TRANSFORM,
 294                           BRW_NEW_VERTEX_PROGRAM |
 295                           BRW_NEW_VS_ATTRIB_WORKAROUNDS);
 296 }
 297
 298 void
 299 brw_vs_populate_key(struct brw_context *brw,
 300                     struct brw_vs_prog_key *key)
 301 {
 302    struct gl_context *ctx = &brw->ctx;
 303    /* BRW_NEW_VERTEX_PROGRAM */
 304    struct brw_program *vp = (struct brw_program *)brw->vertex_program;
 305    struct gl_program *prog = (struct gl_program *) brw->vertex_program;
 306
 307    memset(key, 0, sizeof(*key));
 308
 309    /* Just upload the program verbatim for now.  Always send it all
 310     * the inputs it asks for, whether they are varying or not.
 311     */
 312    key->program_string_id = vp->id;
 313
 314    if (ctx->Transform.ClipPlanesEnabled != 0 &&
 315        (ctx->API == API_OPENGL_COMPAT || ctx->API == API_OPENGLES) &&
 316        vp->program.ClipDistanceArraySize == 0) {
 317       key->nr_userclip_plane_consts =
 318          _mesa_logbase2(ctx->Transform.ClipPlanesEnabled) + 1;
 319    }
 320
 321    if (brw->gen < 6) {
 322       /* _NEW_POLYGON */
 323       key->copy_edgeflag = (ctx->Polygon.FrontMode != GL_FILL ||
 324                             ctx->Polygon.BackMode != GL_FILL);
 325
 326       /* _NEW_POINT */
 327       if (ctx->Point.PointSprite) {
 328          key->point_coord_replace = ctx->Point.CoordReplace & 0xff;
 329       }
 330    }
 331
 332    if (prog->nir->info->outputs_written &
 333        (VARYING_BIT_COL0 | VARYING_BIT_COL1 | VARYING_BIT_BFC0 |
 334         VARYING_BIT_BFC1)) {
 335       /* _NEW_LIGHT | _NEW_BUFFERS */
 336       key->clamp_vertex_color = ctx->Light._ClampVertexColor;
 337    }
 338
 339    /* _NEW_TEXTURE */
 340    brw_populate_sampler_prog_key_data(ctx, prog, &key->tex);
 341
 342    /* BRW_NEW_VS_ATTRIB_WORKAROUNDS */
 343    if (brw->gen < 8 && !brw->is_haswell) {
 344       memcpy(key->gl_attrib_wa_flags, brw->vb.attrib_wa_flags,
 345              sizeof(brw->vb.attrib_wa_flags));
 346    }
 347 }
 348
 349 void
 350 brw_upload_vs_prog(struct brw_context *brw)
 351 {
 352    struct gl_context *ctx = &brw->ctx;
 353    struct gl_shader_program **current = ctx->_Shader->CurrentProgram;
 354    struct brw_vs_prog_key key;
 355    /* BRW_NEW_VERTEX_PROGRAM */
 356    struct brw_program *vp = (struct brw_program *)brw->vertex_program;
 357
 358    if (!brw_vs_state_dirty(brw))
 359       return;
 360
 361    brw_vs_populate_key(brw, &key);
 362
 363    if (!brw_search_cache(&brw->cache, BRW_CACHE_VS_PROG,
 364                          &key, sizeof(key),
 365                          &brw->vs.base.prog_offset, &brw->vs.base.prog_data)) {
 366       bool success = brw_codegen_vs_prog(brw, current[MESA_SHADER_VERTEX],
 367                                          vp, &key);
 368       (void) success;
 369       assert(success);
 370    }
 371 }
 372
 373 bool
 374 brw_vs_precompile(struct gl_context *ctx,
 375                   struct gl_shader_program *shader_prog,
 376                   struct gl_program *prog)
 377 {
 378    struct brw_context *brw = brw_context(ctx);
 379    struct brw_vs_prog_key key;
 380    uint32_t old_prog_offset = brw->vs.base.prog_offset;
 381    struct brw_stage_prog_data *old_prog_data = brw->vs.base.prog_data;
 382    bool success;
 383
 384    struct brw_program *bvp = brw_program(prog);
 385
 386    memset(&key, 0, sizeof(key));
 387
 388    brw_setup_tex_for_precompile(brw, &key.tex, prog);
 389    key.program_string_id = bvp->id;
 390    key.clamp_vertex_color =
 391       (prog->nir->info->outputs_written &
 392        (VARYING_BIT_COL0 | VARYING_BIT_COL1 | VARYING_BIT_BFC0 |
 393         VARYING_BIT_BFC1));
 394
 395    success = brw_codegen_vs_prog(brw, shader_prog, bvp, &key);
 396
 397    brw->vs.base.prog_offset = old_prog_offset;
 398    brw->vs.base.prog_data = old_prog_data;
 399
 400    return success;
 401 }