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