src/gallium/drivers/llvmpipe/lp_rast.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * 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, sub license, 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 portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include <limits.h>
  29 #include "util/u_memory.h"
  30 #include "util/u_math.h"
  31 #include "util/u_cpu_detect.h"
  32 #include "util/u_surface.h"
  33
  34 #include "lp_scene_queue.h"
  35 #include "lp_debug.h"
  36 #include "lp_fence.h"
  37 #include "lp_rast.h"
  38 #include "lp_rast_priv.h"
  39 #include "lp_tile_soa.h"
  40 #include "lp_bld_debug.h"
  41 #include "lp_scene.h"
  42
  43
  44 /**
  45  * Begin the rasterization phase.
  46  * Map the framebuffer surfaces.  Initialize the 'rast' state.
  47  */
  48 static boolean
  49 lp_rast_begin( struct lp_rasterizer *rast,
  50                const struct pipe_framebuffer_state *fb,
  51                boolean write_color,
  52                boolean write_zstencil )
  53 {
  54    struct pipe_screen *screen = rast->screen;
  55    struct pipe_surface *cbuf, *zsbuf;
  56    int i;
  57
  58    LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
  59
  60    util_copy_framebuffer_state(&rast->state.fb, fb);
  61
  62    rast->state.write_zstencil = write_zstencil;
  63    rast->state.write_color = write_color;
  64
  65    rast->check_for_clipped_tiles = (fb->width % TILE_SIZE != 0 ||
  66                                     fb->height % TILE_SIZE != 0);
  67
  68
  69    for (i = 0; i < rast->state.fb.nr_cbufs; i++) {
  70       cbuf = rast->state.fb.cbufs[i];
  71       if (cbuf) {
  72          rast->cbuf_transfer[i] = screen->get_tex_transfer(rast->screen,
  73                                                            cbuf->texture,
  74                                                            cbuf->face,
  75                                                            cbuf->level,
  76                                                            cbuf->zslice,
  77                                                            PIPE_TRANSFER_READ_WRITE,
  78                                                            0, 0,
  79                                                            cbuf->width,
  80                                                            cbuf->height);
  81          if (!rast->cbuf_transfer[i])
  82             goto fail;
  83
  84          rast->cbuf_map[i] = screen->transfer_map(rast->screen,
  85                                                   rast->cbuf_transfer[i]);
  86          if (!rast->cbuf_map[i])
  87             goto fail;
  88       }
  89    }
  90
  91    zsbuf = rast->state.fb.zsbuf;
  92    if (zsbuf) {
  93       rast->zsbuf_transfer = screen->get_tex_transfer(rast->screen,
  94                                                       zsbuf->texture,
  95                                                       zsbuf->face,
  96                                                       zsbuf->level,
  97                                                       zsbuf->zslice,
  98                                                       PIPE_TRANSFER_READ_WRITE,
  99                                                       0, 0,
 100                                                       zsbuf->width,
 101                                                       zsbuf->height);
 102       if (!rast->zsbuf_transfer)
 103          goto fail;
 104
 105       rast->zsbuf_map = screen->transfer_map(rast->screen,
 106                                             rast->zsbuf_transfer);
 107       if (!rast->zsbuf_map)
 108          goto fail;
 109    }
 110
 111    return TRUE;
 112
 113 fail:
 114    /* Unmap and release transfers?
 115     */
 116    return FALSE;
 117 }
 118
 119
 120 /**
 121  * Finish the rasterization phase.
 122  * Unmap framebuffer surfaces.
 123  */
 124 static void
 125 lp_rast_end( struct lp_rasterizer *rast )
 126 {
 127    struct pipe_screen *screen = rast->screen;
 128    unsigned i;
 129
 130    for (i = 0; i < rast->state.fb.nr_cbufs; i++) {
 131       if (rast->cbuf_map[i])
 132          screen->transfer_unmap(screen, rast->cbuf_transfer[i]);
 133
 134       if (rast->cbuf_transfer[i])
 135          screen->tex_transfer_destroy(rast->cbuf_transfer[i]);
 136
 137       rast->cbuf_transfer[i] = NULL;
 138       rast->cbuf_map[i] = NULL;
 139    }
 140
 141    if (rast->zsbuf_map)
 142       screen->transfer_unmap(screen, rast->zsbuf_transfer);
 143
 144    if (rast->zsbuf_transfer)
 145       screen->tex_transfer_destroy(rast->zsbuf_transfer);
 146
 147    rast->zsbuf_transfer = NULL;
 148    rast->zsbuf_map = NULL;
 149 }
 150
 151
 152 /**
 153  * Begining rasterization of a tile.
 154  * \param x  window X position of the tile, in pixels
 155  * \param y  window Y position of the tile, in pixels
 156  */
 157 static void
 158 lp_rast_start_tile( struct lp_rasterizer *rast,
 159                     unsigned thread_index,
 160                     unsigned x, unsigned y )
 161 {
 162    LP_DBG(DEBUG_RAST, "%s %d,%d\n", __FUNCTION__, x, y);
 163
 164    rast->tasks[thread_index].x = x;
 165    rast->tasks[thread_index].y = y;
 166 }
 167
 168
 169 /**
 170  * Clear the rasterizer's current color tile.
 171  * This is a bin command called during bin processing.
 172  */
 173 void lp_rast_clear_color( struct lp_rasterizer *rast,
 174                           unsigned thread_index,
 175                           const union lp_rast_cmd_arg arg )
 176 {
 177    const uint8_t *clear_color = arg.clear_color;
 178    uint8_t **color_tile = rast->tasks[thread_index].tile.color;
 179    unsigned i;
 180
 181    LP_DBG(DEBUG_RAST, "%s 0x%x,0x%x,0x%x,0x%x\n", __FUNCTION__,
 182               clear_color[0],
 183               clear_color[1],
 184               clear_color[2],
 185               clear_color[3]);
 186
 187    if (clear_color[0] == clear_color[1] &&
 188        clear_color[1] == clear_color[2] &&
 189        clear_color[2] == clear_color[3]) {
 190       /* clear to grayscale value {x, x, x, x} */
 191       for (i = 0; i < rast->state.fb.nr_cbufs; i++) {
 192          memset(color_tile[i], clear_color[0], TILE_SIZE * TILE_SIZE * 4);
 193       }
 194    }
 195    else {
 196       /* Non-gray color.
 197        * Note: if the swizzled tile layout changes (see TILE_PIXEL) this code
 198        * will need to change.  It'll be pretty obvious when clearing no longer
 199        * works.
 200        */
 201       const unsigned chunk = TILE_SIZE / 4;
 202       for (i = 0; i < rast->state.fb.nr_cbufs; i++) {
 203          uint8_t *c = color_tile[i];
 204          unsigned j;
 205          for (j = 0; j < 4 * TILE_SIZE; j++) {
 206             memset(c, clear_color[0], chunk);
 207             c += chunk;
 208             memset(c, clear_color[1], chunk);
 209             c += chunk;
 210             memset(c, clear_color[2], chunk);
 211             c += chunk;
 212             memset(c, clear_color[3], chunk);
 213             c += chunk;
 214          }
 215          assert(c - color_tile[i] == TILE_SIZE * TILE_SIZE * 4);
 216       }
 217    }
 218 }
 219
 220
 221 /**
 222  * Clear the rasterizer's current z/stencil tile.
 223  * This is a bin command called during bin processing.
 224  */
 225 void lp_rast_clear_zstencil( struct lp_rasterizer *rast,
 226                              unsigned thread_index,
 227                              const union lp_rast_cmd_arg arg)
 228 {
 229    unsigned i;
 230    uint32_t *depth_tile = rast->tasks[thread_index].tile.depth;
 231
 232    LP_DBG(DEBUG_RAST, "%s 0x%x\n", __FUNCTION__, arg.clear_zstencil);
 233
 234    for (i = 0; i < TILE_SIZE * TILE_SIZE; i++)
 235       depth_tile[i] = arg.clear_zstencil;
 236 }
 237
 238
 239 /**
 240  * Load tile color from the framebuffer surface.
 241  * This is a bin command called during bin processing.
 242  */
 243 void lp_rast_load_color( struct lp_rasterizer *rast,
 244                          unsigned thread_index,
 245                          const union lp_rast_cmd_arg arg)
 246 {
 247    struct lp_rasterizer_task *task = &rast->tasks[thread_index];
 248    const unsigned x = task->x;
 249    const unsigned y = task->y;
 250    unsigned i;
 251
 252    LP_DBG(DEBUG_RAST, "%s at %u, %u\n", __FUNCTION__, x, y);
 253
 254    for (i = 0; i < rast->state.fb.nr_cbufs; i++) {
 255       struct pipe_transfer *transfer = rast->cbuf_transfer[i];
 256       int w = TILE_SIZE;
 257       int h = TILE_SIZE;
 258
 259       if (x >= transfer->width)
 260          continue;
 261
 262       if (y >= transfer->height)
 263          continue;
 264
 265       assert(w >= 0);
 266       assert(h >= 0);
 267       assert(w <= TILE_SIZE);
 268       assert(h <= TILE_SIZE);
 269
 270       lp_tile_read_4ub(transfer->texture->format,
 271                        task->tile.color[i],
 272                        rast->cbuf_map[i],
 273                        transfer->stride,
 274                        x, y,
 275                        w, h);
 276    }
 277 }
 278
 279
 280 static void
 281 lp_tile_read_z32(uint32_t *tile,
 282                  const uint8_t *map,
 283                  unsigned map_stride,
 284                  unsigned x0, unsigned y0, unsigned w, unsigned h)
 285 {
 286    unsigned x, y;
 287    const uint8_t *map_row = map + y0*map_stride;
 288    for (y = 0; y < h; ++y) {
 289       const uint32_t *map_pixel = (uint32_t *)(map_row + x0*4);
 290       for (x = 0; x < w; ++x) {
 291          *tile++ = *map_pixel++;
 292       }
 293       map_row += map_stride;
 294    }
 295 }
 296
 297 /**
 298  * Load tile z/stencil from the framebuffer surface.
 299  * This is a bin command called during bin processing.
 300  */
 301 void lp_rast_load_zstencil( struct lp_rasterizer *rast,
 302                             unsigned thread_index,
 303                             const union lp_rast_cmd_arg arg )
 304 {
 305    struct lp_rasterizer_task *task = &rast->tasks[thread_index];
 306    const unsigned x = task->x;
 307    const unsigned y = task->y;
 308    unsigned w = TILE_SIZE;
 309    unsigned h = TILE_SIZE;
 310
 311    if (x + w > rast->state.fb.width)
 312       w -= x + w - rast->state.fb.width;
 313
 314    if (y + h > rast->state.fb.height)
 315       h -= y + h - rast->state.fb.height;
 316
 317    LP_DBG(DEBUG_RAST, "%s %d,%d %dx%d\n", __FUNCTION__, x, y, w, h);
 318
 319    assert(rast->zsbuf_transfer->texture->format == PIPE_FORMAT_Z32_UNORM);
 320    lp_tile_read_z32(task->tile.depth,
 321                     rast->zsbuf_map,
 322                     rast->zsbuf_transfer->stride,
 323                     x, y, w, h);
 324 }
 325
 326
 327 void lp_rast_set_state( struct lp_rasterizer *rast,
 328                         unsigned thread_index,
 329                         const union lp_rast_cmd_arg arg )
 330 {
 331    const struct lp_rast_state *state = arg.set_state;
 332
 333    LP_DBG(DEBUG_RAST, "%s %p\n", __FUNCTION__, (void *) state);
 334
 335    /* just set the current state pointer for this rasterizer */
 336    rast->tasks[thread_index].current_state = state;
 337 }
 338
 339
 340
 341 /**
 342  * Run the shader on all blocks in a tile.  This is used when a tile is
 343  * completely contained inside a triangle.
 344  * This is a bin command called during bin processing.
 345  */
 346 void lp_rast_shade_tile( struct lp_rasterizer *rast,
 347                          unsigned thread_index,
 348                          const union lp_rast_cmd_arg arg )
 349 {
 350    struct lp_rasterizer_task *task = &rast->tasks[thread_index];
 351    const struct lp_rast_state *state = task->current_state;
 352    struct lp_rast_tile *tile = &task->tile;
 353    const struct lp_rast_shader_inputs *inputs = arg.shade_tile;
 354    const unsigned tile_x = task->x;
 355    const unsigned tile_y = task->y;
 356    unsigned x, y;
 357
 358    LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
 359
 360    /* render the whole 64x64 tile in 4x4 chunks */
 361    for (y = 0; y < TILE_SIZE; y += 4){
 362       for (x = 0; x < TILE_SIZE; x += 4) {
 363          uint8_t *color[PIPE_MAX_COLOR_BUFS];
 364          uint32_t *depth;
 365          unsigned block_offset, i;
 366
 367          /* offset of the 16x16 pixel block within the tile */
 368          block_offset = ((y / 4) * (16 * 16) + (x / 4) * 16);
 369
 370          /* color buffer */
 371          for (i = 0; i < rast->state.fb.nr_cbufs; i++)
 372             color[i] = tile->color[i] + 4 * block_offset;
 373
 374          /* depth buffer */
 375          depth = tile->depth + block_offset;
 376
 377          /* run shader */
 378          state->jit_function[0]( &state->jit_context,
 379                                  tile_x + x, tile_y + y,
 380                                  inputs->a0,
 381                                  inputs->dadx,
 382                                  inputs->dady,
 383                                  color,
 384                                  depth,
 385                                  INT_MIN, INT_MIN, INT_MIN,
 386                                  NULL, NULL, NULL );
 387       }
 388    }
 389 }
 390
 391
 392 /**
 393  * Compute shading for a 4x4 block of pixels.
 394  * This is a bin command called during bin processing.
 395  */
 396 void lp_rast_shade_quads( struct lp_rasterizer *rast,
 397                           unsigned thread_index,
 398                           const struct lp_rast_shader_inputs *inputs,
 399                           unsigned x, unsigned y,
 400                           int32_t c1, int32_t c2, int32_t c3)
 401 {
 402    struct lp_rasterizer_task *task = &rast->tasks[thread_index];
 403    const struct lp_rast_state *state = task->current_state;
 404    struct lp_rast_tile *tile = &task->tile;
 405    uint8_t *color[PIPE_MAX_COLOR_BUFS];
 406    void *depth;
 407    unsigned i;
 408    unsigned ix, iy;
 409    int block_offset;
 410
 411 #ifdef DEBUG
 412    assert(state);
 413
 414    /* Sanity checks */
 415    assert(x % TILE_VECTOR_WIDTH == 0);
 416    assert(y % TILE_VECTOR_HEIGHT == 0);
 417
 418    assert((x % 4) == 0);
 419    assert((y % 4) == 0);
 420 #endif
 421
 422    ix = x % TILE_SIZE;
 423    iy = y % TILE_SIZE;
 424
 425    /* offset of the 16x16 pixel block within the tile */
 426    block_offset = ((iy / 4) * (16 * 16) + (ix / 4) * 16);
 427
 428    /* color buffer */
 429    for (i = 0; i < rast->state.fb.nr_cbufs; i++)
 430       color[i] = tile->color[i] + 4 * block_offset;
 431
 432    /* depth buffer */
 433    depth = tile->depth + block_offset;
 434
 435
 436
 437 #ifdef DEBUG
 438    assert(lp_check_alignment(tile->depth, 16));
 439    assert(lp_check_alignment(tile->color[0], 16));
 440    assert(lp_check_alignment(state->jit_context.blend_color, 16));
 441
 442    assert(lp_check_alignment(inputs->step[0], 16));
 443    assert(lp_check_alignment(inputs->step[1], 16));
 444    assert(lp_check_alignment(inputs->step[2], 16));
 445 #endif
 446
 447    /* run shader */
 448    state->jit_function[1]( &state->jit_context,
 449                         x, y,
 450                         inputs->a0,
 451                         inputs->dadx,
 452                         inputs->dady,
 453                         color,
 454                         depth,
 455                         c1, c2, c3,
 456                         inputs->step[0], inputs->step[1], inputs->step[2]);
 457 }
 458
 459
 460 /**
 461  * Set top row and left column of the tile's pixels to white.  For debugging.
 462  */
 463 static void
 464 outline_tile(uint8_t *tile)
 465 {
 466    const uint8_t val = 0xff;
 467    unsigned i;
 468
 469    for (i = 0; i < TILE_SIZE; i++) {
 470       TILE_PIXEL(tile, i, 0, 0) = val;
 471       TILE_PIXEL(tile, i, 0, 1) = val;
 472       TILE_PIXEL(tile, i, 0, 2) = val;
 473       TILE_PIXEL(tile, i, 0, 3) = val;
 474
 475       TILE_PIXEL(tile, 0, i, 0) = val;
 476       TILE_PIXEL(tile, 0, i, 1) = val;
 477       TILE_PIXEL(tile, 0, i, 2) = val;
 478       TILE_PIXEL(tile, 0, i, 3) = val;
 479    }
 480 }
 481
 482
 483 /**
 484  * Draw grid of gray lines at 16-pixel intervals across the tile to
 485  * show the sub-tile boundaries.  For debugging.
 486  */
 487 static void
 488 outline_subtiles(uint8_t *tile)
 489 {
 490    const uint8_t val = 0x80;
 491    const unsigned step = 16;
 492    unsigned i, j;
 493
 494    for (i = 0; i < TILE_SIZE; i += step) {
 495       for (j = 0; j < TILE_SIZE; j++) {
 496          TILE_PIXEL(tile, i, j, 0) = val;
 497          TILE_PIXEL(tile, i, j, 1) = val;
 498          TILE_PIXEL(tile, i, j, 2) = val;
 499          TILE_PIXEL(tile, i, j, 3) = val;
 500
 501          TILE_PIXEL(tile, j, i, 0) = val;
 502          TILE_PIXEL(tile, j, i, 1) = val;
 503          TILE_PIXEL(tile, j, i, 2) = val;
 504          TILE_PIXEL(tile, j, i, 3) = val;
 505       }
 506    }
 507
 508    outline_tile(tile);
 509 }
 510
 511
 512
 513 /**
 514  * Write the rasterizer's color tile to the framebuffer.
 515  */
 516 static void lp_rast_store_color( struct lp_rasterizer *rast,
 517                                  unsigned thread_index)
 518 {
 519    struct lp_rasterizer_task *task = &rast->tasks[thread_index];
 520    const unsigned x = task->x;
 521    const unsigned y = task->y;
 522    unsigned i;
 523
 524    for (i = 0; i < rast->state.fb.nr_cbufs; i++) {
 525       struct pipe_transfer *transfer = rast->cbuf_transfer[i];
 526       int w = TILE_SIZE;
 527       int h = TILE_SIZE;
 528
 529       if (x >= transfer->width)
 530          continue;
 531
 532       if (y >= transfer->height)
 533          continue;
 534
 535       LP_DBG(DEBUG_RAST, "%s [%u] %d,%d %dx%d\n", __FUNCTION__,
 536              thread_index, x, y, w, h);
 537
 538       if (LP_DEBUG & DEBUG_SHOW_SUBTILES)
 539          outline_subtiles(task->tile.color[i]);
 540       else if (LP_DEBUG & DEBUG_SHOW_TILES)
 541          outline_tile(task->tile.color[i]);
 542
 543       lp_tile_write_4ub(transfer->texture->format,
 544                         task->tile.color[i],
 545                         rast->cbuf_map[i],
 546                         transfer->stride,
 547                         x, y,
 548                         w, h);
 549    }
 550 }
 551
 552
 553 static void
 554 lp_tile_write_z32(const uint32_t *src, uint8_t *dst, unsigned dst_stride,
 555                   unsigned x0, unsigned y0, unsigned w, unsigned h)
 556 {
 557    unsigned x, y;
 558    uint8_t *dst_row = dst + y0*dst_stride;
 559    for (y = 0; y < h; ++y) {
 560       uint32_t *dst_pixel = (uint32_t *)(dst_row + x0*4);
 561       for (x = 0; x < w; ++x) {
 562          *dst_pixel++ = *src++;
 563       }
 564       dst_row += dst_stride;
 565    }
 566 }
 567
 568 /**
 569  * Write the rasterizer's z/stencil tile to the framebuffer.
 570  */
 571 static void lp_rast_store_zstencil( struct lp_rasterizer *rast,
 572                                     unsigned thread_index )
 573 {
 574    struct lp_rasterizer_task *task = &rast->tasks[thread_index];
 575    const unsigned x = task->x;
 576    const unsigned y = task->y;
 577    unsigned w = TILE_SIZE;
 578    unsigned h = TILE_SIZE;
 579
 580    if (x + w > rast->state.fb.width)
 581       w -= x + w - rast->state.fb.width;
 582
 583    if (y + h > rast->state.fb.height)
 584       h -= y + h - rast->state.fb.height;
 585
 586    LP_DBG(DEBUG_RAST, "%s %d,%d %dx%d\n", __FUNCTION__, x, y, w, h);
 587
 588    assert(rast->zsbuf_transfer->texture->format == PIPE_FORMAT_Z32_UNORM);
 589    lp_tile_write_z32(task->tile.depth,
 590                      rast->zsbuf_map,
 591                      rast->zsbuf_transfer->stride,
 592                      x, y, w, h);
 593 }
 594
 595
 596 /**
 597  * Write the rasterizer's tiles to the framebuffer.
 598  */
 599 static void
 600 lp_rast_end_tile( struct lp_rasterizer *rast,
 601                   unsigned thread_index )
 602 {
 603    LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
 604
 605    if (rast->state.write_color)
 606       lp_rast_store_color(rast, thread_index);
 607
 608    if (rast->state.write_zstencil)
 609       lp_rast_store_zstencil(rast, thread_index);
 610 }
 611
 612
 613 /**
 614  * Signal on a fence.  This is called during bin execution/rasterization.
 615  * Called per thread.
 616  */
 617 void lp_rast_fence( struct lp_rasterizer *rast,
 618                     unsigned thread_index,
 619                     const union lp_rast_cmd_arg arg )
 620 {
 621    struct lp_fence *fence = arg.fence;
 622
 623    pipe_mutex_lock( fence->mutex );
 624
 625    fence->count++;
 626    assert(fence->count <= fence->rank);
 627
 628    LP_DBG(DEBUG_RAST, "%s count=%u rank=%u\n", __FUNCTION__,
 629           fence->count, fence->rank);
 630
 631    pipe_condvar_signal( fence->signalled );
 632
 633    pipe_mutex_unlock( fence->mutex );
 634 }
 635
 636
 637 /**
 638  * When all the threads are done rasterizing a scene, one thread will
 639  * call this function to reset the scene and put it onto the empty queue.
 640  */
 641 static void
 642 release_scene( struct lp_rasterizer *rast,
 643                struct lp_scene *scene )
 644 {
 645    util_unreference_framebuffer_state( &scene->fb );
 646
 647    lp_scene_reset( scene );
 648    lp_scene_enqueue( rast->empty_scenes, scene );
 649    rast->curr_scene = NULL;
 650 }
 651
 652
 653 /**
 654  * Rasterize commands for a single bin.
 655  * \param x, y  position of the bin's tile in the framebuffer
 656  * Must be called between lp_rast_begin() and lp_rast_end().
 657  * Called per thread.
 658  */
 659 static void
 660 rasterize_bin( struct lp_rasterizer *rast,
 661                unsigned thread_index,
 662                const struct cmd_bin *bin,
 663                int x, int y)
 664 {
 665    const struct cmd_block_list *commands = &bin->commands;
 666    struct cmd_block *block;
 667    unsigned k;
 668
 669    lp_rast_start_tile( rast, thread_index, x, y );
 670
 671    /* simply execute each of the commands in the block list */
 672    for (block = commands->head; block; block = block->next) {
 673       for (k = 0; k < block->count; k++) {
 674          block->cmd[k]( rast, thread_index, block->arg[k] );
 675       }
 676    }
 677
 678    lp_rast_end_tile( rast, thread_index );
 679 }
 680
 681
 682 #define RAST(x) { lp_rast_##x, #x }
 683
 684 static struct {
 685    lp_rast_cmd cmd;
 686    const char *name;
 687 } cmd_names[] =
 688 {
 689    RAST(load_color),
 690    RAST(load_zstencil),
 691    RAST(clear_color),
 692    RAST(clear_zstencil),
 693    RAST(triangle),
 694    RAST(shade_tile),
 695    RAST(set_state),
 696    RAST(fence),
 697 };
 698
 699 static void
 700 debug_bin( const struct cmd_bin *bin )
 701 {
 702    const struct cmd_block *head = bin->commands.head;
 703    int i, j;
 704
 705    for (i = 0; i < head->count; i++) {
 706       debug_printf("%d: ", i);
 707       for (j = 0; j < Elements(cmd_names); j++) {
 708          if (head->cmd[i] == cmd_names[j].cmd) {
 709             debug_printf("%s\n", cmd_names[j].name);
 710             break;
 711          }
 712       }
 713       if (j == Elements(cmd_names))
 714          debug_printf("...other\n");
 715    }
 716
 717 }
 718
 719 /* An empty bin is one that just loads the contents of the tile and
 720  * stores them again unchanged.  This typically happens when bins have
 721  * been flushed for some reason in the middle of a frame, or when
 722  * incremental updates are being made to a render target.
 723  *
 724  * Try to avoid doing pointless work in this case.
 725  */
 726 static boolean
 727 is_empty_bin( const struct cmd_bin *bin )
 728 {
 729    const struct cmd_block *head = bin->commands.head;
 730    int i;
 731
 732    if (0)
 733       debug_bin(bin);
 734
 735    /* We emit at most two load-tile commands at the start of the first
 736     * command block.  In addition we seem to emit a couple of
 737     * set-state commands even in empty bins.
 738     *
 739     * As a heuristic, if a bin has more than 4 commands, consider it
 740     * non-empty.
 741     */
 742    if (head->next != NULL ||
 743        head->count > 4) {
 744       return FALSE;
 745    }
 746
 747    for (i = 0; i < head->count; i++)
 748       if (head->cmd[i] != lp_rast_load_color &&
 749           head->cmd[i] != lp_rast_load_zstencil &&
 750           head->cmd[i] != lp_rast_set_state) {
 751          return FALSE;
 752       }
 753
 754    return TRUE;
 755 }
 756
 757
 758
 759 /**
 760  * Rasterize/execute all bins within a scene.
 761  * Called per thread.
 762  */
 763 static void
 764 rasterize_scene( struct lp_rasterizer *rast,
 765                 unsigned thread_index,
 766                 struct lp_scene *scene,
 767                 bool write_depth )
 768 {
 769    /* loop over scene bins, rasterize each */
 770 #if 0
 771    {
 772       unsigned i, j;
 773       for (i = 0; i < scene->tiles_x; i++) {
 774          for (j = 0; j < scene->tiles_y; j++) {
 775             struct cmd_bin *bin = lp_get_bin(scene, i, j);
 776             rasterize_bin( rast, thread_index,
 777                            bin, i * TILE_SIZE, j * TILE_SIZE );
 778          }
 779       }
 780    }
 781 #else
 782    {
 783       struct cmd_bin *bin;
 784       int x, y;
 785
 786       assert(scene);
 787       while ((bin = lp_scene_bin_iter_next(scene, &x, &y))) {
 788          if (!is_empty_bin( bin ))
 789             rasterize_bin( rast, thread_index, bin, x * TILE_SIZE, y * TILE_SIZE);
 790       }
 791    }
 792 #endif
 793 }
 794
 795
 796 /**
 797  * Called by setup module when it has something for us to render.
 798  */
 799 void
 800 lp_rasterize_scene( struct lp_rasterizer *rast,
 801                    struct lp_scene *scene,
 802                    const struct pipe_framebuffer_state *fb,
 803                    bool write_depth )
 804 {
 805    boolean debug = false;
 806
 807    LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
 808
 809    if (debug) {
 810       unsigned x, y;
 811       printf("rasterize scene:\n");
 812       printf("  data size: %u\n", lp_scene_data_size(scene));
 813       for (y = 0; y < scene->tiles_y; y++) {
 814          for (x = 0; x < scene->tiles_x; x++) {
 815             printf("  bin %u, %u size: %u\n", x, y,
 816                    lp_scene_bin_size(scene, x, y));
 817          }
 818       }
 819    }
 820
 821    /* save framebuffer state in the bin */
 822    util_copy_framebuffer_state(&scene->fb, fb);
 823    scene->write_depth = write_depth;
 824
 825    if (rast->num_threads == 0) {
 826       /* no threading */
 827
 828       lp_rast_begin( rast, fb,
 829                      fb->nr_cbufs != 0, /* always write color if cbufs present */
 830                      fb->zsbuf != NULL && write_depth );
 831
 832       lp_scene_bin_iter_begin( scene );
 833       rasterize_scene( rast, 0, scene, write_depth );
 834
 835       release_scene( rast, scene );
 836
 837       lp_rast_end( rast );
 838    }
 839    else {
 840       /* threaded rendering! */
 841       unsigned i;
 842
 843       lp_scene_enqueue( rast->full_scenes, scene );
 844
 845       /* signal the threads that there's work to do */
 846       for (i = 0; i < rast->num_threads; i++) {
 847          pipe_semaphore_signal(&rast->tasks[i].work_ready);
 848       }
 849
 850       /* wait for work to complete */
 851       for (i = 0; i < rast->num_threads; i++) {
 852          pipe_semaphore_wait(&rast->tasks[i].work_done);
 853       }
 854    }
 855
 856    LP_DBG(DEBUG_SETUP, "%s done \n", __FUNCTION__);
 857 }
 858
 859
 860 /**
 861  * This is the thread's main entrypoint.
 862  * It's a simple loop:
 863  *   1. wait for work
 864  *   2. do work
 865  *   3. signal that we're done
 866  */
 867 static void *
 868 thread_func( void *init_data )
 869 {
 870    struct lp_rasterizer_task *task = (struct lp_rasterizer_task *) init_data;
 871    struct lp_rasterizer *rast = task->rast;
 872    boolean debug = false;
 873
 874    while (1) {
 875       /* wait for work */
 876       if (debug)
 877          debug_printf("thread %d waiting for work\n", task->thread_index);
 878       pipe_semaphore_wait(&task->work_ready);
 879
 880       if (task->thread_index == 0) {
 881          /* thread[0]:
 882           *  - get next scene to rasterize
 883           *  - map the framebuffer surfaces
 884           */
 885          const struct pipe_framebuffer_state *fb;
 886          boolean write_depth;
 887
 888          rast->curr_scene = lp_scene_dequeue( rast->full_scenes, TRUE );
 889
 890          lp_scene_bin_iter_begin( rast->curr_scene );
 891
 892          fb = &rast->curr_scene->fb;
 893          write_depth = rast->curr_scene->write_depth;
 894
 895          lp_rast_begin( rast, fb,
 896                         fb->nr_cbufs != 0,
 897                         fb->zsbuf != NULL && write_depth );
 898       }
 899
 900       /* Wait for all threads to get here so that threads[1+] don't
 901        * get a null rast->curr_scene pointer.
 902        */
 903       pipe_barrier_wait( &rast->barrier );
 904
 905       /* do work */
 906       if (debug)
 907          debug_printf("thread %d doing work\n", task->thread_index);
 908       rasterize_scene(rast,
 909                      task->thread_index,
 910                      rast->curr_scene,
 911                      rast->curr_scene->write_depth);
 912
 913       /* wait for all threads to finish with this scene */
 914       pipe_barrier_wait( &rast->barrier );
 915
 916       if (task->thread_index == 0) {
 917          /* thread[0]:
 918           * - release the scene object
 919           * - unmap the framebuffer surfaces
 920           */
 921          release_scene( rast, rast->curr_scene );
 922          lp_rast_end( rast );
 923       }
 924
 925       /* signal done with work */
 926       if (debug)
 927          debug_printf("thread %d done working\n", task->thread_index);
 928       pipe_semaphore_signal(&task->work_done);
 929    }
 930
 931    return NULL;
 932 }
 933
 934
 935 /**
 936  * Initialize semaphores and spawn the threads.
 937  */
 938 static void
 939 create_rast_threads(struct lp_rasterizer *rast)
 940 {
 941    unsigned i;
 942
 943    rast->num_threads = util_cpu_caps.nr_cpus;
 944    rast->num_threads = debug_get_num_option("LP_NUM_THREADS", rast->num_threads);
 945    rast->num_threads = MIN2(rast->num_threads, MAX_THREADS);
 946
 947    /* NOTE: if num_threads is zero, we won't use any threads */
 948    for (i = 0; i < rast->num_threads; i++) {
 949       pipe_semaphore_init(&rast->tasks[i].work_ready, 0);
 950       pipe_semaphore_init(&rast->tasks[i].work_done, 0);
 951       rast->threads[i] = pipe_thread_create(thread_func,
 952                                             (void *) &rast->tasks[i]);
 953    }
 954 }
 955
 956
 957
 958 /**
 959  * Create new lp_rasterizer.
 960  * \param empty  the queue to put empty scenes on after we've finished
 961  *               processing them.
 962  */
 963 struct lp_rasterizer *
 964 lp_rast_create( struct pipe_screen *screen, struct lp_scene_queue *empty )
 965 {
 966    struct lp_rasterizer *rast;
 967    unsigned i, cbuf;
 968
 969    rast = CALLOC_STRUCT(lp_rasterizer);
 970    if(!rast)
 971       return NULL;
 972
 973    rast->screen = screen;
 974
 975    rast->empty_scenes = empty;
 976    rast->full_scenes = lp_scene_queue_create();
 977
 978    for (i = 0; i < Elements(rast->tasks); i++) {
 979       struct lp_rasterizer_task *task = &rast->tasks[i];
 980
 981       for (cbuf = 0; cbuf < PIPE_MAX_COLOR_BUFS; cbuf++ )
 982          task->tile.color[cbuf] = align_malloc(TILE_SIZE * TILE_SIZE * 4, 16);
 983
 984       task->tile.depth = align_malloc(TILE_SIZE * TILE_SIZE * 4, 16);
 985       task->rast = rast;
 986       task->thread_index = i;
 987    }
 988
 989    create_rast_threads(rast);
 990
 991    /* for synchronizing rasterization threads */
 992    pipe_barrier_init( &rast->barrier, rast->num_threads );
 993
 994    return rast;
 995 }
 996
 997
 998 /* Shutdown:
 999  */
1000 void lp_rast_destroy( struct lp_rasterizer *rast )
1001 {
1002    unsigned i, cbuf;
1003
1004    util_unreference_framebuffer_state(&rast->state.fb);
1005
1006    for (i = 0; i < Elements(rast->tasks); i++) {
1007       align_free(rast->tasks[i].tile.depth);
1008       for (cbuf = 0; cbuf < PIPE_MAX_COLOR_BUFS; cbuf++ )
1009          align_free(rast->tasks[i].tile.color[cbuf]);
1010    }
1011
1012    /* for synchronizing rasterization threads */
1013    pipe_barrier_destroy( &rast->barrier );
1014
1015    FREE(rast);
1016 }
1017
1018
1019 /** Return number of rasterization threads */
1020 unsigned
1021 lp_rast_get_num_threads( struct lp_rasterizer *rast )
1022 {
1023    return rast->num_threads;
1024 }