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       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 struct shader_times {
 291    uint64_t time;
 292    uint64_t written;
 293    uint64_t reset;
 294 };
 295
 296 void
 297 brw_init_shader_time(struct brw_context *brw)
 298 {
 299    const int max_entries = 2048;
 300    brw->shader_time.bo =
 301       drm_intel_bo_alloc(brw->bufmgr, "shader time",
 302                          max_entries * SHADER_TIME_STRIDE * 3, 4096);
 303    brw->shader_time.names = rzalloc_array(brw, const char *, max_entries);
 304    brw->shader_time.ids = rzalloc_array(brw, int, max_entries);
 305    brw->shader_time.types = rzalloc_array(brw, enum shader_time_shader_type,
 306                                           max_entries);
 307    brw->shader_time.cumulative = rzalloc_array(brw, struct shader_times,
 308                                                max_entries);
 309    brw->shader_time.max_entries = max_entries;
 310 }
 311
 312 static int
 313 compare_time(const void *a, const void *b)
 314 {
 315    uint64_t * const *a_val = a;
 316    uint64_t * const *b_val = b;
 317
 318    /* We don't just subtract because we're turning the value to an int. */
 319    if (**a_val < **b_val)
 320       return -1;
 321    else if (**a_val == **b_val)
 322       return 0;
 323    else
 324       return 1;
 325 }
 326
 327 static void
 328 print_shader_time_line(const char *stage, const char *name,
 329                        int shader_num, uint64_t time, uint64_t total)
 330 {
 331    fprintf(stderr, "%-6s%-18s", stage, name);
 332
 333    if (shader_num != 0)
 334       fprintf(stderr, "%4d: ", shader_num);
 335    else
 336       fprintf(stderr, "    : ");
 337
 338    fprintf(stderr, "%16lld (%7.2f Gcycles)      %4.1f%%\n",
 339            (long long)time,
 340            (double)time / 1000000000.0,
 341            (double)time / total * 100.0);
 342 }
 343
 344 static void
 345 brw_report_shader_time(struct brw_context *brw)
 346 {
 347    if (!brw->shader_time.bo || !brw->shader_time.num_entries)
 348       return;
 349
 350    uint64_t scaled[brw->shader_time.num_entries];
 351    uint64_t *sorted[brw->shader_time.num_entries];
 352    uint64_t total_by_type[ST_CS + 1];
 353    memset(total_by_type, 0, sizeof(total_by_type));
 354    double total = 0;
 355    for (int i = 0; i < brw->shader_time.num_entries; i++) {
 356       uint64_t written = 0, reset = 0;
 357       enum shader_time_shader_type type = brw->shader_time.types[i];
 358
 359       sorted[i] = &scaled[i];
 360
 361       switch (type) {
 362       case ST_VS:
 363       case ST_GS:
 364       case ST_FS8:
 365       case ST_FS16:
 366       case ST_CS:
 367          written = brw->shader_time.cumulative[i].written;
 368          reset = brw->shader_time.cumulative[i].reset;
 369          break;
 370
 371       default:
 372          /* I sometimes want to print things that aren't the 3 shader times.
 373           * Just print the sum in that case.
 374           */
 375          written = 1;
 376          reset = 0;
 377          break;
 378       }
 379
 380       uint64_t time = brw->shader_time.cumulative[i].time;
 381       if (written) {
 382          scaled[i] = time / written * (written + reset);
 383       } else {
 384          scaled[i] = time;
 385       }
 386
 387       switch (type) {
 388       case ST_VS:
 389       case ST_GS:
 390       case ST_FS8:
 391       case ST_FS16:
 392       case ST_CS:
 393          total_by_type[type] += scaled[i];
 394          break;
 395       default:
 396          break;
 397       }
 398
 399       total += scaled[i];
 400    }
 401
 402    if (total == 0) {
 403       fprintf(stderr, "No shader time collected yet\n");
 404       return;
 405    }
 406
 407    qsort(sorted, brw->shader_time.num_entries, sizeof(sorted[0]), compare_time);
 408
 409    fprintf(stderr, "\n");
 410    fprintf(stderr, "type          ID                  cycles spent                   %% of total\n");
 411    for (int s = 0; s < brw->shader_time.num_entries; s++) {
 412       const char *stage;
 413       /* Work back from the sorted pointers times to a time to print. */
 414       int i = sorted[s] - scaled;
 415
 416       if (scaled[i] == 0)
 417          continue;
 418
 419       int shader_num = brw->shader_time.ids[i];
 420       const char *shader_name = brw->shader_time.names[i];
 421
 422       switch (brw->shader_time.types[i]) {
 423       case ST_VS:
 424          stage = "vs";
 425          break;
 426       case ST_GS:
 427          stage = "gs";
 428          break;
 429       case ST_FS8:
 430          stage = "fs8";
 431          break;
 432       case ST_FS16:
 433          stage = "fs16";
 434          break;
 435       case ST_CS:
 436          stage = "cs";
 437          break;
 438       default:
 439          stage = "other";
 440          break;
 441       }
 442
 443       print_shader_time_line(stage, shader_name, shader_num,
 444                              scaled[i], total);
 445    }
 446
 447    fprintf(stderr, "\n");
 448    print_shader_time_line("total", "vs", 0, total_by_type[ST_VS], total);
 449    print_shader_time_line("total", "gs", 0, total_by_type[ST_GS], total);
 450    print_shader_time_line("total", "fs8", 0, total_by_type[ST_FS8], total);
 451    print_shader_time_line("total", "fs16", 0, total_by_type[ST_FS16], total);
 452    print_shader_time_line("total", "cs", 0, total_by_type[ST_CS], total);
 453 }
 454
 455 static void
 456 brw_collect_shader_time(struct brw_context *brw)
 457 {
 458    if (!brw->shader_time.bo)
 459       return;
 460
 461    /* This probably stalls on the last rendering.  We could fix that by
 462     * delaying reading the reports, but it doesn't look like it's a big
 463     * overhead compared to the cost of tracking the time in the first place.
 464     */
 465    drm_intel_bo_map(brw->shader_time.bo, true);
 466    void *bo_map = brw->shader_time.bo->virtual;
 467
 468    for (int i = 0; i < brw->shader_time.num_entries; i++) {
 469       uint32_t *times = bo_map + i * 3 * SHADER_TIME_STRIDE;
 470
 471       brw->shader_time.cumulative[i].time += times[SHADER_TIME_STRIDE * 0 / 4];
 472       brw->shader_time.cumulative[i].written += times[SHADER_TIME_STRIDE * 1 / 4];
 473       brw->shader_time.cumulative[i].reset += times[SHADER_TIME_STRIDE * 2 / 4];
 474    }
 475
 476    /* Zero the BO out to clear it out for our next collection.
 477     */
 478    memset(bo_map, 0, brw->shader_time.bo->size);
 479    drm_intel_bo_unmap(brw->shader_time.bo);
 480 }
 481
 482 void
 483 brw_collect_and_report_shader_time(struct brw_context *brw)
 484 {
 485    brw_collect_shader_time(brw);
 486
 487    if (brw->shader_time.report_time == 0 ||
 488        get_time() - brw->shader_time.report_time >= 1.0) {
 489       brw_report_shader_time(brw);
 490       brw->shader_time.report_time = get_time();
 491    }
 492 }
 493
 494 /**
 495  * Chooses an index in the shader_time buffer and sets up tracking information
 496  * for our printouts.
 497  *
 498  * Note that this holds on to references to the underlying programs, which may
 499  * change their lifetimes compared to normal operation.
 500  */
 501 int
 502 brw_get_shader_time_index(struct brw_context *brw,
 503                           struct gl_shader_program *shader_prog,
 504                           struct gl_program *prog,
 505                           enum shader_time_shader_type type)
 506 {
 507    int shader_time_index = brw->shader_time.num_entries++;
 508    assert(shader_time_index < brw->shader_time.max_entries);
 509    brw->shader_time.types[shader_time_index] = type;
 510
 511    int id = shader_prog ? shader_prog->Name : prog->Id;
 512    const char *name;
 513    if (id == 0) {
 514       name = "ff";
 515    } else if (!shader_prog) {
 516       name = "prog";
 517    } else if (shader_prog->Label) {
 518       name = ralloc_strdup(brw->shader_time.names, shader_prog->Label);
 519    } else {
 520       name = "glsl";
 521    }
 522
 523    brw->shader_time.names[shader_time_index] = name;
 524    brw->shader_time.ids[shader_time_index] = id;
 525
 526    return shader_time_index;
 527 }
 528
 529 void
 530 brw_destroy_shader_time(struct brw_context *brw)
 531 {
 532    drm_intel_bo_unreference(brw->shader_time.bo);
 533    brw->shader_time.bo = NULL;
 534 }
 535
 536 void
 537 brw_mark_surface_used(struct brw_stage_prog_data *prog_data,
 538                       unsigned surf_index)
 539 {
 540    assert(surf_index < BRW_MAX_SURFACES);
 541
 542    prog_data->binding_table.size_bytes =
 543       MAX2(prog_data->binding_table.size_bytes, (surf_index + 1) * 4);
 544 }
 545
 546 bool
 547 brw_stage_prog_data_compare(const struct brw_stage_prog_data *a,
 548                             const struct brw_stage_prog_data *b)
 549 {
 550    /* Compare all the struct up to the pointers. */
 551    if (memcmp(a, b, offsetof(struct brw_stage_prog_data, param)))
 552       return false;
 553
 554    if (memcmp(a->param, b->param, a->nr_params * sizeof(void *)))
 555       return false;
 556
 557    if (memcmp(a->pull_param, b->pull_param, a->nr_pull_params * sizeof(void *)))
 558       return false;
 559
 560    return true;
 561 }
 562
 563 void
 564 brw_stage_prog_data_free(const void *p)
 565 {
 566    struct brw_stage_prog_data *prog_data = (struct brw_stage_prog_data *)p;
 567
 568    ralloc_free(prog_data->param);
 569    ralloc_free(prog_data->pull_param);
 570 }
 571
 572 void
 573 brw_dump_ir(const char *stage, struct gl_shader_program *shader_prog,
 574             struct gl_shader *shader, struct gl_program *prog)
 575 {
 576    if (shader_prog) {
 577       if (shader->ir) {
 578          fprintf(stderr,
 579                  "GLSL IR for native %s shader %d:\n",
 580                  stage, shader_prog->Name);
 581          _mesa_print_ir(stderr, shader->ir, NULL);
 582          fprintf(stderr, "\n\n");
 583       }
 584    } else {
 585       fprintf(stderr, "ARB_%s_program %d ir for native %s shader\n",
 586               stage, prog->Id, stage);
 587       _mesa_print_program(prog);
 588    }
 589 }