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