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