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