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