src/mesa/drivers/dri/i965/brw_program.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 #include <pthread.h>
  33 #include "main/imports.h"
  34 #include "main/enums.h"
  35 #include "main/shaderobj.h"
  36 #include "program/prog_parameter.h"
  37 #include "program/prog_print.h"
  38 #include "program/program.h"
  39 #include "program/programopt.h"
  40 #include "tnl/tnl.h"
  41 #include "util/ralloc.h"
  42 #include "glsl/ir.h"
  43
  44 #include "brw_context.h"
  45 #include "brw_shader.h"
  46 #include "brw_nir.h"
  47 #include "brw_wm.h"
  48 #include "intel_batchbuffer.h"
  49
  50 static unsigned
  51 get_new_program_id(struct intel_screen *screen)
  52 {
  53    static pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
  54    pthread_mutex_lock(&m);
  55    unsigned id = screen->program_id++;
  56    pthread_mutex_unlock(&m);
  57    return id;
  58 }
  59
  60 static struct gl_program *brwNewProgram( struct gl_context *ctx,
  61                                       GLenum target,
  62                                       GLuint id )
  63 {
  64    struct brw_context *brw = brw_context(ctx);
  65
  66    switch (target) {
  67    case GL_VERTEX_PROGRAM_ARB: {
  68       struct brw_vertex_program *prog = CALLOC_STRUCT(brw_vertex_program);
  69       if (prog) {
  70          prog->id = get_new_program_id(brw->intelScreen);
  71
  72          return _mesa_init_gl_program(&prog->program.Base, target, id);
  73       }
  74       else
  75          return NULL;
  76    }
  77
  78    case GL_FRAGMENT_PROGRAM_ARB: {
  79       struct brw_fragment_program *prog = CALLOC_STRUCT(brw_fragment_program);
  80       if (prog) {
  81          prog->id = get_new_program_id(brw->intelScreen);
  82
  83          return _mesa_init_gl_program(&prog->program.Base, target, id);
  84       }
  85       else
  86          return NULL;
  87    }
  88
  89    case GL_GEOMETRY_PROGRAM_NV: {
  90       struct brw_geometry_program *prog = CALLOC_STRUCT(brw_geometry_program);
  91       if (prog) {
  92          prog->id = get_new_program_id(brw->intelScreen);
  93
  94          return _mesa_init_gl_program(&prog->program.Base, target, id);
  95       } else {
  96          return NULL;
  97       }
  98    }
  99
 100    case GL_COMPUTE_PROGRAM_NV: {
 101       struct brw_compute_program *prog = CALLOC_STRUCT(brw_compute_program);
 102       if (prog) {
 103          prog->id = get_new_program_id(brw->intelScreen);
 104
 105          return _mesa_init_gl_program(&prog->program.Base, target, id);
 106       } else {
 107          return NULL;
 108       }
 109    }
 110
 111    default:
 112       unreachable("Unsupported target in brwNewProgram()");
 113    }
 114 }
 115
 116 static void brwDeleteProgram( struct gl_context *ctx,
 117                               struct gl_program *prog )
 118 {
 119    _mesa_delete_program( ctx, prog );
 120 }
 121
 122
 123 static GLboolean
 124 brwProgramStringNotify(struct gl_context *ctx,
 125                        GLenum target,
 126                        struct gl_program *prog)
 127 {
 128    struct brw_context *brw = brw_context(ctx);
 129    const struct brw_compiler *compiler = brw->intelScreen->compiler;
 130
 131    switch (target) {
 132    case GL_FRAGMENT_PROGRAM_ARB: {
 133       struct gl_fragment_program *fprog = (struct gl_fragment_program *) prog;
 134       struct brw_fragment_program *newFP = brw_fragment_program(fprog);
 135       const struct brw_fragment_program *curFP =
 136          brw_fragment_program_const(brw->fragment_program);
 137
 138       if (newFP == curFP)
 139          brw->ctx.NewDriverState |= BRW_NEW_FRAGMENT_PROGRAM;
 140       newFP->id = get_new_program_id(brw->intelScreen);
 141
 142       brw_add_texrect_params(prog);
 143
 144       prog->nir = brw_create_nir(brw, NULL, prog, MESA_SHADER_FRAGMENT, true);
 145
 146       brw_fs_precompile(ctx, NULL, prog);
 147       break;
 148    }
 149    case GL_VERTEX_PROGRAM_ARB: {
 150       struct gl_vertex_program *vprog = (struct gl_vertex_program *) prog;
 151       struct brw_vertex_program *newVP = brw_vertex_program(vprog);
 152       const struct brw_vertex_program *curVP =
 153          brw_vertex_program_const(brw->vertex_program);
 154
 155       if (newVP == curVP)
 156          brw->ctx.NewDriverState |= BRW_NEW_VERTEX_PROGRAM;
 157       if (newVP->program.IsPositionInvariant) {
 158          _mesa_insert_mvp_code(ctx, &newVP->program);
 159       }
 160       newVP->id = get_new_program_id(brw->intelScreen);
 161
 162       /* Also tell tnl about it:
 163        */
 164       _tnl_program_string(ctx, target, prog);
 165
 166       brw_add_texrect_params(prog);
 167
 168       prog->nir = brw_create_nir(brw, NULL, prog, MESA_SHADER_VERTEX,
 169                                  compiler->scalar_stage[MESA_SHADER_VERTEX]);
 170
 171       brw_vs_precompile(ctx, NULL, prog);
 172       break;
 173    }
 174    default:
 175       /*
 176        * driver->ProgramStringNotify is only called for ARB programs, fixed
 177        * function vertex programs, and ir_to_mesa (which isn't used by the
 178        * i965 back-end).  Therefore, even after geometry shaders are added,
 179        * this function should only ever be called with a target of
 180        * GL_VERTEX_PROGRAM_ARB or GL_FRAGMENT_PROGRAM_ARB.
 181        */
 182       unreachable("Unexpected target in brwProgramStringNotify");
 183    }
 184
 185    return true;
 186 }
 187
 188 static void
 189 brw_memory_barrier(struct gl_context *ctx, GLbitfield barriers)
 190 {
 191    struct brw_context *brw = brw_context(ctx);
 192    unsigned bits = (PIPE_CONTROL_DATA_CACHE_INVALIDATE |
 193                     PIPE_CONTROL_NO_WRITE |
 194                     PIPE_CONTROL_CS_STALL);
 195    assert(brw->gen >= 7 && brw->gen <= 9);
 196
 197    if (barriers & (GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT |
 198                    GL_ELEMENT_ARRAY_BARRIER_BIT |
 199                    GL_COMMAND_BARRIER_BIT))
 200       bits |= PIPE_CONTROL_VF_CACHE_INVALIDATE;
 201
 202    if (barriers & GL_UNIFORM_BARRIER_BIT)
 203       bits |= (PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE |
 204                PIPE_CONTROL_CONST_CACHE_INVALIDATE);
 205
 206    if (barriers & GL_TEXTURE_FETCH_BARRIER_BIT)
 207       bits |= PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE;
 208
 209    if (barriers & GL_TEXTURE_UPDATE_BARRIER_BIT)
 210       bits |= PIPE_CONTROL_RENDER_TARGET_FLUSH;
 211
 212    if (barriers & GL_FRAMEBUFFER_BARRIER_BIT)
 213       bits |= (PIPE_CONTROL_DEPTH_CACHE_FLUSH |
 214                PIPE_CONTROL_RENDER_TARGET_FLUSH);
 215
 216    /* Typed surface messages are handled by the render cache on IVB, so we
 217     * need to flush it too.
 218     */
 219    if (brw->gen == 7 && !brw->is_haswell)
 220       bits |= PIPE_CONTROL_RENDER_TARGET_FLUSH;
 221
 222    brw_emit_pipe_control_flush(brw, bits);
 223 }
 224
 225 void
 226 brw_add_texrect_params(struct gl_program *prog)
 227 {
 228    for (int texunit = 0; texunit < BRW_MAX_TEX_UNIT; texunit++) {
 229       if (!(prog->TexturesUsed[texunit] & (1 << TEXTURE_RECT_INDEX)))
 230          continue;
 231
 232       int tokens[STATE_LENGTH] = {
 233          STATE_INTERNAL,
 234          STATE_TEXRECT_SCALE,
 235          texunit,
 236          0,
 237          0
 238       };
 239
 240       _mesa_add_state_reference(prog->Parameters, (gl_state_index *)tokens);
 241    }
 242 }
 243
 244 void
 245 brw_get_scratch_bo(struct brw_context *brw,
 246                    drm_intel_bo **scratch_bo, int size)
 247 {
 248    drm_intel_bo *old_bo = *scratch_bo;
 249
 250    if (old_bo && old_bo->size < size) {
 251       drm_intel_bo_unreference(old_bo);
 252       old_bo = NULL;
 253    }
 254
 255    if (!old_bo) {
 256       *scratch_bo = drm_intel_bo_alloc(brw->bufmgr, "scratch bo", size, 4096);
 257    }
 258 }
 259
 260 void brwInitFragProgFuncs( struct dd_function_table *functions )
 261 {
 262    assert(functions->ProgramStringNotify == _tnl_program_string);
 263
 264    functions->NewProgram = brwNewProgram;
 265    functions->DeleteProgram = brwDeleteProgram;
 266    functions->ProgramStringNotify = brwProgramStringNotify;
 267
 268    functions->NewShader = brw_new_shader;
 269    functions->LinkShader = brw_link_shader;
 270
 271    functions->MemoryBarrier = brw_memory_barrier;
 272 }
 273
 274 struct shader_times {
 275    uint64_t time;
 276    uint64_t written;
 277    uint64_t reset;
 278 };
 279
 280 void
 281 brw_init_shader_time(struct brw_context *brw)
 282 {
 283    const int max_entries = 2048;
 284    brw->shader_time.bo =
 285       drm_intel_bo_alloc(brw->bufmgr, "shader time",
 286                          max_entries * SHADER_TIME_STRIDE * 3, 4096);
 287    brw->shader_time.names = rzalloc_array(brw, const char *, max_entries);
 288    brw->shader_time.ids = rzalloc_array(brw, int, max_entries);
 289    brw->shader_time.types = rzalloc_array(brw, enum shader_time_shader_type,
 290                                           max_entries);
 291    brw->shader_time.cumulative = rzalloc_array(brw, struct shader_times,
 292                                                max_entries);
 293    brw->shader_time.max_entries = max_entries;
 294 }
 295
 296 static int
 297 compare_time(const void *a, const void *b)
 298 {
 299    uint64_t * const *a_val = a;
 300    uint64_t * const *b_val = b;
 301
 302    /* We don't just subtract because we're turning the value to an int. */
 303    if (**a_val < **b_val)
 304       return -1;
 305    else if (**a_val == **b_val)
 306       return 0;
 307    else
 308       return 1;
 309 }
 310
 311 static void
 312 print_shader_time_line(const char *stage, const char *name,
 313                        int shader_num, uint64_t time, uint64_t total)
 314 {
 315    fprintf(stderr, "%-6s%-18s", stage, name);
 316
 317    if (shader_num != 0)
 318       fprintf(stderr, "%4d: ", shader_num);
 319    else
 320       fprintf(stderr, "    : ");
 321
 322    fprintf(stderr, "%16lld (%7.2f Gcycles)      %4.1f%%\n",
 323            (long long)time,
 324            (double)time / 1000000000.0,
 325            (double)time / total * 100.0);
 326 }
 327
 328 static void
 329 brw_report_shader_time(struct brw_context *brw)
 330 {
 331    if (!brw->shader_time.bo || !brw->shader_time.num_entries)
 332       return;
 333
 334    uint64_t scaled[brw->shader_time.num_entries];
 335    uint64_t *sorted[brw->shader_time.num_entries];
 336    uint64_t total_by_type[ST_CS + 1];
 337    memset(total_by_type, 0, sizeof(total_by_type));
 338    double total = 0;
 339    for (int i = 0; i < brw->shader_time.num_entries; i++) {
 340       uint64_t written = 0, reset = 0;
 341       enum shader_time_shader_type type = brw->shader_time.types[i];
 342
 343       sorted[i] = &scaled[i];
 344
 345       switch (type) {
 346       case ST_VS:
 347       case ST_TCS:
 348       case ST_TES:
 349       case ST_GS:
 350       case ST_FS8:
 351       case ST_FS16:
 352       case ST_CS:
 353          written = brw->shader_time.cumulative[i].written;
 354          reset = brw->shader_time.cumulative[i].reset;
 355          break;
 356
 357       default:
 358          /* I sometimes want to print things that aren't the 3 shader times.
 359           * Just print the sum in that case.
 360           */
 361          written = 1;
 362          reset = 0;
 363          break;
 364       }
 365
 366       uint64_t time = brw->shader_time.cumulative[i].time;
 367       if (written) {
 368          scaled[i] = time / written * (written + reset);
 369       } else {
 370          scaled[i] = time;
 371       }
 372
 373       switch (type) {
 374       case ST_VS:
 375       case ST_TCS:
 376       case ST_TES:
 377       case ST_GS:
 378       case ST_FS8:
 379       case ST_FS16:
 380       case ST_CS:
 381          total_by_type[type] += scaled[i];
 382          break;
 383       default:
 384          break;
 385       }
 386
 387       total += scaled[i];
 388    }
 389
 390    if (total == 0) {
 391       fprintf(stderr, "No shader time collected yet\n");
 392       return;
 393    }
 394
 395    qsort(sorted, brw->shader_time.num_entries, sizeof(sorted[0]), compare_time);
 396
 397    fprintf(stderr, "\n");
 398    fprintf(stderr, "type          ID                  cycles spent                   %% of total\n");
 399    for (int s = 0; s < brw->shader_time.num_entries; s++) {
 400       const char *stage;
 401       /* Work back from the sorted pointers times to a time to print. */
 402       int i = sorted[s] - scaled;
 403
 404       if (scaled[i] == 0)
 405          continue;
 406
 407       int shader_num = brw->shader_time.ids[i];
 408       const char *shader_name = brw->shader_time.names[i];
 409
 410       switch (brw->shader_time.types[i]) {
 411       case ST_VS:
 412          stage = "vs";
 413          break;
 414       case ST_TCS:
 415          stage = "tcs";
 416          break;
 417       case ST_TES:
 418          stage = "tes";
 419          break;
 420       case ST_GS:
 421          stage = "gs";
 422          break;
 423       case ST_FS8:
 424          stage = "fs8";
 425          break;
 426       case ST_FS16:
 427          stage = "fs16";
 428          break;
 429       case ST_CS:
 430          stage = "cs";
 431          break;
 432       default:
 433          stage = "other";
 434          break;
 435       }
 436
 437       print_shader_time_line(stage, shader_name, shader_num,
 438                              scaled[i], total);
 439    }
 440
 441    fprintf(stderr, "\n");
 442    print_shader_time_line("total", "vs", 0, total_by_type[ST_VS], total);
 443    print_shader_time_line("total", "tcs", 0, total_by_type[ST_TCS], total);
 444    print_shader_time_line("total", "tes", 0, total_by_type[ST_TES], total);
 445    print_shader_time_line("total", "gs", 0, total_by_type[ST_GS], total);
 446    print_shader_time_line("total", "fs8", 0, total_by_type[ST_FS8], total);
 447    print_shader_time_line("total", "fs16", 0, total_by_type[ST_FS16], total);
 448    print_shader_time_line("total", "cs", 0, total_by_type[ST_CS], total);
 449 }
 450
 451 static void
 452 brw_collect_shader_time(struct brw_context *brw)
 453 {
 454    if (!brw->shader_time.bo)
 455       return;
 456
 457    /* This probably stalls on the last rendering.  We could fix that by
 458     * delaying reading the reports, but it doesn't look like it's a big
 459     * overhead compared to the cost of tracking the time in the first place.
 460     */
 461    drm_intel_bo_map(brw->shader_time.bo, true);
 462    void *bo_map = brw->shader_time.bo->virtual;
 463
 464    for (int i = 0; i < brw->shader_time.num_entries; i++) {
 465       uint32_t *times = bo_map + i * 3 * SHADER_TIME_STRIDE;
 466
 467       brw->shader_time.cumulative[i].time += times[SHADER_TIME_STRIDE * 0 / 4];
 468       brw->shader_time.cumulative[i].written += times[SHADER_TIME_STRIDE * 1 / 4];
 469       brw->shader_time.cumulative[i].reset += times[SHADER_TIME_STRIDE * 2 / 4];
 470    }
 471
 472    /* Zero the BO out to clear it out for our next collection.
 473     */
 474    memset(bo_map, 0, brw->shader_time.bo->size);
 475    drm_intel_bo_unmap(brw->shader_time.bo);
 476 }
 477
 478 void
 479 brw_collect_and_report_shader_time(struct brw_context *brw)
 480 {
 481    brw_collect_shader_time(brw);
 482
 483    if (brw->shader_time.report_time == 0 ||
 484        get_time() - brw->shader_time.report_time >= 1.0) {
 485       brw_report_shader_time(brw);
 486       brw->shader_time.report_time = get_time();
 487    }
 488 }
 489
 490 /**
 491  * Chooses an index in the shader_time buffer and sets up tracking information
 492  * for our printouts.
 493  *
 494  * Note that this holds on to references to the underlying programs, which may
 495  * change their lifetimes compared to normal operation.
 496  */
 497 int
 498 brw_get_shader_time_index(struct brw_context *brw,
 499                           struct gl_shader_program *shader_prog,
 500                           struct gl_program *prog,
 501                           enum shader_time_shader_type type)
 502 {
 503    int shader_time_index = brw->shader_time.num_entries++;
 504    assert(shader_time_index < brw->shader_time.max_entries);
 505    brw->shader_time.types[shader_time_index] = type;
 506
 507    int id = shader_prog ? shader_prog->Name : prog->Id;
 508    const char *name;
 509    if (id == 0) {
 510       name = "ff";
 511    } else if (!shader_prog) {
 512       name = "prog";
 513    } else if (shader_prog->Label) {
 514       name = ralloc_strdup(brw->shader_time.names, shader_prog->Label);
 515    } else {
 516       name = "glsl";
 517    }
 518
 519    brw->shader_time.names[shader_time_index] = name;
 520    brw->shader_time.ids[shader_time_index] = id;
 521
 522    return shader_time_index;
 523 }
 524
 525 void
 526 brw_destroy_shader_time(struct brw_context *brw)
 527 {
 528    drm_intel_bo_unreference(brw->shader_time.bo);
 529    brw->shader_time.bo = NULL;
 530 }
 531
 532 void
 533 brw_stage_prog_data_free(const void *p)
 534 {
 535    struct brw_stage_prog_data *prog_data = (struct brw_stage_prog_data *)p;
 536
 537    ralloc_free(prog_data->param);
 538    ralloc_free(prog_data->pull_param);
 539    ralloc_free(prog_data->image_param);
 540 }
 541
 542 void
 543 brw_dump_ir(const char *stage, struct gl_shader_program *shader_prog,
 544             struct gl_shader *shader, struct gl_program *prog)
 545 {
 546    if (shader_prog) {
 547       if (shader->ir) {
 548          fprintf(stderr,
 549                  "GLSL IR for native %s shader %d:\n",
 550                  stage, shader_prog->Name);
 551          _mesa_print_ir(stderr, shader->ir, NULL);
 552          fprintf(stderr, "\n\n");
 553       }
 554    } else {
 555       fprintf(stderr, "ARB_%s_program %d ir for native %s shader\n",
 556               stage, prog->Id, stage);
 557       _mesa_print_program(prog);
 558    }
 559 }
 560
 561 void
 562 brw_setup_tex_for_precompile(struct brw_context *brw,
 563                              struct brw_sampler_prog_key_data *tex,
 564                              struct gl_program *prog)
 565 {
 566    const bool has_shader_channel_select = brw->is_haswell || brw->gen >= 8;
 567    unsigned sampler_count = _mesa_fls(prog->SamplersUsed);
 568    for (unsigned i = 0; i < sampler_count; i++) {
 569       if (!has_shader_channel_select && (prog->ShadowSamplers & (1 << i))) {
 570          /* Assume DEPTH_TEXTURE_MODE is the default: X, X, X, 1 */
 571          tex->swizzles[i] =
 572             MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_ONE);
 573       } else {
 574          /* Color sampler: assume no swizzling. */
 575          tex->swizzles[i] = SWIZZLE_XYZW;
 576       }
 577    }
 578 }