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_rect.h"
  32 #include "util/u_surface.h"
  33 #include "util/u_pack_color.h"
  34
  35 #include "lp_scene_queue.h"
  36 #include "lp_debug.h"
  37 #include "lp_fence.h"
  38 #include "lp_perf.h"
  39 #include "lp_query.h"
  40 #include "lp_rast.h"
  41 #include "lp_rast_priv.h"
  42 #include "lp_tile_soa.h"
  43 #include "gallivm/lp_bld_debug.h"
  44 #include "lp_scene.h"
  45
  46
  47 #ifdef DEBUG
  48 int jit_line = 0;
  49 const struct lp_rast_state *jit_state = NULL;
  50 const struct lp_rasterizer_task *jit_task = NULL;
  51 #endif
  52
  53
  54 /**
  55  * Begin rasterizing a scene.
  56  * Called once per scene by one thread.
  57  */
  58 static void
  59 lp_rast_begin( struct lp_rasterizer *rast,
  60                struct lp_scene *scene )
  61 {
  62
  63    rast->curr_scene = scene;
  64
  65    LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
  66
  67    lp_scene_begin_rasterization( scene );
  68    lp_scene_bin_iter_begin( scene );
  69 }
  70
  71
  72 static void
  73 lp_rast_end( struct lp_rasterizer *rast )
  74 {
  75    lp_scene_end_rasterization( rast->curr_scene );
  76
  77    rast->curr_scene = NULL;
  78
  79 #ifdef DEBUG
  80    if (0)
  81       debug_printf("Post render scene: tile unswizzle: %u tile swizzle: %u\n",
  82                    lp_tile_unswizzle_count, lp_tile_swizzle_count);
  83 #endif
  84 }
  85
  86
  87 /**
  88  * Begining rasterization of a tile.
  89  * \param x  window X position of the tile, in pixels
  90  * \param y  window Y position of the tile, in pixels
  91  */
  92 static void
  93 lp_rast_tile_begin(struct lp_rasterizer_task *task,
  94                    const struct cmd_bin *bin)
  95 {
  96    const struct lp_scene *scene = task->scene;
  97    enum lp_texture_usage usage;
  98
  99    LP_DBG(DEBUG_RAST, "%s %d,%d\n", __FUNCTION__, bin->x, bin->y);
 100
 101    task->bin = bin;
 102    task->x = bin->x * TILE_SIZE;
 103    task->y = bin->y * TILE_SIZE;
 104
 105    /* reset pointers to color tile(s) */
 106    memset(task->color_tiles, 0, sizeof(task->color_tiles));
 107
 108    /* get pointer to depth/stencil tile */
 109    {
 110       struct pipe_surface *zsbuf = task->scene->fb.zsbuf;
 111       if (zsbuf) {
 112          struct llvmpipe_resource *lpt = llvmpipe_resource(zsbuf->texture);
 113
 114          if (scene->has_depthstencil_clear)
 115             usage = LP_TEX_USAGE_WRITE_ALL;
 116          else
 117             usage = LP_TEX_USAGE_READ_WRITE;
 118
 119          /* "prime" the tile: convert data from linear to tiled if necessary
 120           * and update the tile's layout info.
 121           */
 122          (void) llvmpipe_get_texture_tile(lpt,
 123                                           zsbuf->u.tex.first_layer,
 124                                           zsbuf->u.tex.level,
 125                                           usage,
 126                                           task->x,
 127                                           task->y);
 128          /* Get actual pointer to the tile data.  Note that depth/stencil
 129           * data is tiled differently than color data.
 130           */
 131          task->depth_tile = lp_rast_get_depth_block_pointer(task,
 132                                                             task->x,
 133                                                             task->y);
 134
 135          assert(task->depth_tile);
 136       }
 137       else {
 138          task->depth_tile = NULL;
 139       }
 140    }
 141 }
 142
 143
 144 /**
 145  * Clear the rasterizer's current color tile.
 146  * This is a bin command called during bin processing.
 147  */
 148 static void
 149 lp_rast_clear_color(struct lp_rasterizer_task *task,
 150                     const union lp_rast_cmd_arg arg)
 151 {
 152    const struct lp_scene *scene = task->scene;
 153    const uint8_t *clear_color = arg.clear_color;
 154
 155    unsigned i;
 156
 157    LP_DBG(DEBUG_RAST, "%s 0x%x,0x%x,0x%x,0x%x\n", __FUNCTION__,
 158               clear_color[0],
 159               clear_color[1],
 160               clear_color[2],
 161               clear_color[3]);
 162
 163    if (clear_color[0] == clear_color[1] &&
 164        clear_color[1] == clear_color[2] &&
 165        clear_color[2] == clear_color[3]) {
 166       /* clear to grayscale value {x, x, x, x} */
 167       for (i = 0; i < scene->fb.nr_cbufs; i++) {
 168          uint8_t *ptr =
 169             lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL);
 170          memset(ptr, clear_color[0], TILE_SIZE * TILE_SIZE * 4);
 171       }
 172    }
 173    else {
 174       /* Non-gray color.
 175        * Note: if the swizzled tile layout changes (see TILE_PIXEL) this code
 176        * will need to change.  It'll be pretty obvious when clearing no longer
 177        * works.
 178        */
 179       const unsigned chunk = TILE_SIZE / 4;
 180       for (i = 0; i < scene->fb.nr_cbufs; i++) {
 181          uint8_t *c =
 182             lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL);
 183          unsigned j;
 184
 185          for (j = 0; j < 4 * TILE_SIZE; j++) {
 186             memset(c, clear_color[0], chunk);
 187             c += chunk;
 188             memset(c, clear_color[1], chunk);
 189             c += chunk;
 190             memset(c, clear_color[2], chunk);
 191             c += chunk;
 192             memset(c, clear_color[3], chunk);
 193             c += chunk;
 194          }
 195       }
 196    }
 197
 198    LP_COUNT(nr_color_tile_clear);
 199 }
 200
 201
 202
 203
 204
 205
 206 /**
 207  * Clear the rasterizer's current z/stencil tile.
 208  * This is a bin command called during bin processing.
 209  */
 210 static void
 211 lp_rast_clear_zstencil(struct lp_rasterizer_task *task,
 212                        const union lp_rast_cmd_arg arg)
 213 {
 214    const struct lp_scene *scene = task->scene;
 215    uint32_t clear_value = arg.clear_zstencil.value;
 216    uint32_t clear_mask = arg.clear_zstencil.mask;
 217    const unsigned height = TILE_SIZE / TILE_VECTOR_HEIGHT;
 218    const unsigned width = TILE_SIZE * TILE_VECTOR_HEIGHT;
 219    const unsigned block_size = scene->zsbuf.blocksize;
 220    const unsigned dst_stride = scene->zsbuf.stride * TILE_VECTOR_HEIGHT;
 221    uint8_t *dst;
 222    unsigned i, j;
 223
 224    LP_DBG(DEBUG_RAST, "%s: value=0x%08x, mask=0x%08x\n",
 225            __FUNCTION__, clear_value, clear_mask);
 226
 227    /*
 228     * Clear the aera of the swizzled depth/depth buffer matching this tile, in
 229     * stripes of TILE_VECTOR_HEIGHT x TILE_SIZE at a time.
 230     *
 231     * The swizzled depth format is such that the depths for
 232     * TILE_VECTOR_HEIGHT x TILE_VECTOR_WIDTH pixels have consecutive offsets.
 233     */
 234
 235    dst = task->depth_tile;
 236
 237    clear_value &= clear_mask;
 238
 239    switch (block_size) {
 240    case 1:
 241       assert(clear_mask == 0xff);
 242       memset(dst, (uint8_t) clear_value, height * width);
 243       break;
 244    case 2:
 245       if (clear_mask == 0xffff) {
 246          for (i = 0; i < height; i++) {
 247             uint16_t *row = (uint16_t *)dst;
 248             for (j = 0; j < width; j++)
 249                *row++ = (uint16_t) clear_value;
 250             dst += dst_stride;
 251          }
 252       }
 253       else {
 254          for (i = 0; i < height; i++) {
 255             uint16_t *row = (uint16_t *)dst;
 256             for (j = 0; j < width; j++) {
 257                uint16_t tmp = ~clear_mask & *row;
 258                *row++ = clear_value | tmp;
 259             }
 260             dst += dst_stride;
 261          }
 262       }
 263       break;
 264    case 4:
 265       if (clear_mask == 0xffffffff) {
 266          for (i = 0; i < height; i++) {
 267             uint32_t *row = (uint32_t *)dst;
 268             for (j = 0; j < width; j++)
 269                *row++ = clear_value;
 270             dst += dst_stride;
 271          }
 272       }
 273       else {
 274          for (i = 0; i < height; i++) {
 275             uint32_t *row = (uint32_t *)dst;
 276             for (j = 0; j < width; j++) {
 277                uint32_t tmp = ~clear_mask & *row;
 278                *row++ = clear_value | tmp;
 279             }
 280             dst += dst_stride;
 281          }
 282       }
 283       break;
 284    default:
 285       assert(0);
 286       break;
 287    }
 288 }
 289
 290
 291
 292 /**
 293  * Convert the color tile from tiled to linear layout.
 294  * This is generally only done when we're flushing the scene just prior to
 295  * SwapBuffers.  If we didn't do this here, we'd have to convert the entire
 296  * tiled color buffer to linear layout in the llvmpipe_texture_unmap()
 297  * function.  It's better to do it here to take advantage of
 298  * threading/parallelism.
 299  * This is a bin command which is stored in all bins.
 300  */
 301 static void
 302 lp_rast_store_linear_color( struct lp_rasterizer_task *task )
 303 {
 304    const struct lp_scene *scene = task->scene;
 305    unsigned buf;
 306
 307    for (buf = 0; buf < scene->fb.nr_cbufs; buf++) {
 308       struct pipe_surface *cbuf = scene->fb.cbufs[buf];
 309       const unsigned layer = cbuf->u.tex.first_layer;
 310       const unsigned level = cbuf->u.tex.level;
 311       struct llvmpipe_resource *lpt = llvmpipe_resource(cbuf->texture);
 312
 313       if (!task->color_tiles[buf])
 314          continue;
 315
 316       llvmpipe_unswizzle_cbuf_tile(lpt,
 317                                    layer,
 318                                    level,
 319                                    task->x, task->y,
 320                                    task->color_tiles[buf]);
 321    }
 322 }
 323
 324
 325
 326 /**
 327  * Run the shader on all blocks in a tile.  This is used when a tile is
 328  * completely contained inside a triangle.
 329  * This is a bin command called during bin processing.
 330  */
 331 static void
 332 lp_rast_shade_tile(struct lp_rasterizer_task *task,
 333                    const union lp_rast_cmd_arg arg)
 334 {
 335    const struct lp_scene *scene = task->scene;
 336    const struct lp_rast_shader_inputs *inputs = arg.shade_tile;
 337    const struct lp_rast_state *state = task->state;
 338    struct lp_fragment_shader_variant *variant = state->variant;
 339    const unsigned tile_x = task->x, tile_y = task->y;
 340    unsigned x, y;
 341
 342    if (inputs->disable) {
 343       /* This command was partially binned and has been disabled */
 344       return;
 345    }
 346
 347    LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
 348
 349    /* render the whole 64x64 tile in 4x4 chunks */
 350    for (y = 0; y < TILE_SIZE; y += 4){
 351       for (x = 0; x < TILE_SIZE; x += 4) {
 352          uint8_t *color[PIPE_MAX_COLOR_BUFS];
 353          uint32_t *depth;
 354          unsigned i;
 355
 356          /* color buffer */
 357          for (i = 0; i < scene->fb.nr_cbufs; i++)
 358             color[i] = lp_rast_get_color_block_pointer(task, i,
 359                                                        tile_x + x, tile_y + y);
 360
 361          /* depth buffer */
 362          depth = lp_rast_get_depth_block_pointer(task, tile_x + x, tile_y + y);
 363
 364          /* run shader on 4x4 block */
 365          BEGIN_JIT_CALL(state, task);
 366          variant->jit_function[RAST_WHOLE]( &state->jit_context,
 367                                             tile_x + x, tile_y + y,
 368                                             inputs->frontfacing,
 369                                             GET_A0(inputs),
 370                                             GET_DADX(inputs),
 371                                             GET_DADY(inputs),
 372                                             color,
 373                                             depth,
 374                                             0xffff,
 375                                             &task->vis_counter);
 376          END_JIT_CALL();
 377       }
 378    }
 379 }
 380
 381
 382 /**
 383  * Run the shader on all blocks in a tile.  This is used when a tile is
 384  * completely contained inside a triangle, and the shader is opaque.
 385  * This is a bin command called during bin processing.
 386  */
 387 static void
 388 lp_rast_shade_tile_opaque(struct lp_rasterizer_task *task,
 389                           const union lp_rast_cmd_arg arg)
 390 {
 391    const struct lp_scene *scene = task->scene;
 392    unsigned i;
 393
 394    LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
 395
 396    /* this will prevent converting the layout from tiled to linear */
 397    for (i = 0; i < scene->fb.nr_cbufs; i++) {
 398       (void)lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL);
 399    }
 400
 401    lp_rast_shade_tile(task, arg);
 402 }
 403
 404
 405 /**
 406  * Compute shading for a 4x4 block of pixels inside a triangle.
 407  * This is a bin command called during bin processing.
 408  * \param x  X position of quad in window coords
 409  * \param y  Y position of quad in window coords
 410  */
 411 void
 412 lp_rast_shade_quads_mask(struct lp_rasterizer_task *task,
 413                          const struct lp_rast_shader_inputs *inputs,
 414                          unsigned x, unsigned y,
 415                          unsigned mask)
 416 {
 417    const struct lp_rast_state *state = task->state;
 418    struct lp_fragment_shader_variant *variant = state->variant;
 419    const struct lp_scene *scene = task->scene;
 420    uint8_t *color[PIPE_MAX_COLOR_BUFS];
 421    void *depth;
 422    unsigned i;
 423
 424    assert(state);
 425
 426    /* Sanity checks */
 427    assert(x % TILE_VECTOR_WIDTH == 0);
 428    assert(y % TILE_VECTOR_HEIGHT == 0);
 429
 430    assert((x % 4) == 0);
 431    assert((y % 4) == 0);
 432
 433    /* color buffer */
 434    for (i = 0; i < scene->fb.nr_cbufs; i++) {
 435       color[i] = lp_rast_get_color_block_pointer(task, i, x, y);
 436       assert(lp_check_alignment(color[i], 16));
 437    }
 438
 439    /* depth buffer */
 440    depth = lp_rast_get_depth_block_pointer(task, x, y);
 441
 442
 443    assert(lp_check_alignment(state->jit_context.blend_color, 16));
 444
 445    /* run shader on 4x4 block */
 446    BEGIN_JIT_CALL(state, task);
 447    variant->jit_function[RAST_EDGE_TEST](&state->jit_context,
 448                                          x, y,
 449                                          inputs->frontfacing,
 450                                          GET_A0(inputs),
 451                                          GET_DADX(inputs),
 452                                          GET_DADY(inputs),
 453                                          color,
 454                                          depth,
 455                                          mask,
 456                                          &task->vis_counter);
 457    END_JIT_CALL();
 458 }
 459
 460
 461
 462 /**
 463  * Begin a new occlusion query.
 464  * This is a bin command put in all bins.
 465  * Called per thread.
 466  */
 467 static void
 468 lp_rast_begin_query(struct lp_rasterizer_task *task,
 469                     const union lp_rast_cmd_arg arg)
 470 {
 471    struct llvmpipe_query *pq = arg.query_obj;
 472
 473    assert(task->query == NULL);
 474    task->vis_counter = 0;
 475    task->query = pq;
 476 }
 477
 478
 479 /**
 480  * End the current occlusion query.
 481  * This is a bin command put in all bins.
 482  * Called per thread.
 483  */
 484 static void
 485 lp_rast_end_query(struct lp_rasterizer_task *task,
 486                   const union lp_rast_cmd_arg arg)
 487 {
 488    assert(task->query);
 489    if (task->query) {
 490       task->query->count[task->thread_index] += task->vis_counter;
 491       task->query = NULL;
 492    }
 493 }
 494
 495
 496 void
 497 lp_rast_set_state(struct lp_rasterizer_task *task,
 498                   const union lp_rast_cmd_arg arg)
 499 {
 500    task->state = arg.state;
 501 }
 502
 503
 504
 505 /**
 506  * Set top row and left column of the tile's pixels to white.  For debugging.
 507  */
 508 static void
 509 outline_tile(uint8_t *tile)
 510 {
 511    const uint8_t val = 0xff;
 512    unsigned i;
 513
 514    for (i = 0; i < TILE_SIZE; i++) {
 515       TILE_PIXEL(tile, i, 0, 0) = val;
 516       TILE_PIXEL(tile, i, 0, 1) = val;
 517       TILE_PIXEL(tile, i, 0, 2) = val;
 518       TILE_PIXEL(tile, i, 0, 3) = val;
 519
 520       TILE_PIXEL(tile, 0, i, 0) = val;
 521       TILE_PIXEL(tile, 0, i, 1) = val;
 522       TILE_PIXEL(tile, 0, i, 2) = val;
 523       TILE_PIXEL(tile, 0, i, 3) = val;
 524    }
 525 }
 526
 527
 528 /**
 529  * Draw grid of gray lines at 16-pixel intervals across the tile to
 530  * show the sub-tile boundaries.  For debugging.
 531  */
 532 static void
 533 outline_subtiles(uint8_t *tile)
 534 {
 535    const uint8_t val = 0x80;
 536    const unsigned step = 16;
 537    unsigned i, j;
 538
 539    for (i = 0; i < TILE_SIZE; i += step) {
 540       for (j = 0; j < TILE_SIZE; j++) {
 541          TILE_PIXEL(tile, i, j, 0) = val;
 542          TILE_PIXEL(tile, i, j, 1) = val;
 543          TILE_PIXEL(tile, i, j, 2) = val;
 544          TILE_PIXEL(tile, i, j, 3) = val;
 545
 546          TILE_PIXEL(tile, j, i, 0) = val;
 547          TILE_PIXEL(tile, j, i, 1) = val;
 548          TILE_PIXEL(tile, j, i, 2) = val;
 549          TILE_PIXEL(tile, j, i, 3) = val;
 550       }
 551    }
 552
 553    outline_tile(tile);
 554 }
 555
 556
 557
 558 /**
 559  * Called when we're done writing to a color tile.
 560  */
 561 static void
 562 lp_rast_tile_end(struct lp_rasterizer_task *task)
 563 {
 564 #ifdef DEBUG
 565    if (LP_DEBUG & (DEBUG_SHOW_SUBTILES | DEBUG_SHOW_TILES)) {
 566       const struct lp_scene *scene = task->scene;
 567       unsigned buf;
 568
 569       for (buf = 0; buf < scene->fb.nr_cbufs; buf++) {
 570          uint8_t *color = lp_rast_get_color_block_pointer(task, buf,
 571                                                           task->x, task->y);
 572
 573          if (LP_DEBUG & DEBUG_SHOW_SUBTILES)
 574             outline_subtiles(color);
 575          else if (LP_DEBUG & DEBUG_SHOW_TILES)
 576             outline_tile(color);
 577       }
 578    }
 579 #else
 580    (void) outline_subtiles;
 581 #endif
 582
 583    lp_rast_store_linear_color(task);
 584
 585    if (task->query) {
 586       union lp_rast_cmd_arg dummy = {0};
 587       lp_rast_end_query(task, dummy);
 588    }
 589
 590    /* debug */
 591    memset(task->color_tiles, 0, sizeof(task->color_tiles));
 592    task->depth_tile = NULL;
 593
 594    task->bin = NULL;
 595 }
 596
 597 static lp_rast_cmd_func dispatch[LP_RAST_OP_MAX] =
 598 {
 599    lp_rast_clear_color,
 600    lp_rast_clear_zstencil,
 601    lp_rast_triangle_1,
 602    lp_rast_triangle_2,
 603    lp_rast_triangle_3,
 604    lp_rast_triangle_4,
 605    lp_rast_triangle_5,
 606    lp_rast_triangle_6,
 607    lp_rast_triangle_7,
 608    lp_rast_triangle_8,
 609    lp_rast_triangle_3_4,
 610    lp_rast_triangle_3_16,
 611    lp_rast_triangle_4_16,
 612    lp_rast_shade_tile,
 613    lp_rast_shade_tile_opaque,
 614    lp_rast_begin_query,
 615    lp_rast_end_query,
 616    lp_rast_set_state,
 617 };
 618
 619
 620 static void
 621 do_rasterize_bin(struct lp_rasterizer_task *task,
 622                  const struct cmd_bin *bin)
 623 {
 624    const struct cmd_block *block;
 625    unsigned k;
 626
 627    if (0)
 628       lp_debug_bin(bin);
 629
 630    for (block = bin->head; block; block = block->next) {
 631       for (k = 0; k < block->count; k++) {
 632          dispatch[block->cmd[k]]( task, block->arg[k] );
 633       }
 634    }
 635 }
 636
 637
 638
 639 /**
 640  * Rasterize commands for a single bin.
 641  * \param x, y  position of the bin's tile in the framebuffer
 642  * Must be called between lp_rast_begin() and lp_rast_end().
 643  * Called per thread.
 644  */
 645 static void
 646 rasterize_bin(struct lp_rasterizer_task *task,
 647               const struct cmd_bin *bin )
 648 {
 649    lp_rast_tile_begin( task, bin );
 650
 651    do_rasterize_bin(task, bin);
 652
 653    lp_rast_tile_end(task);
 654
 655
 656    /* Debug/Perf flags:
 657     */
 658    if (bin->head->count == 1) {
 659       if (bin->head->cmd[0] == LP_RAST_OP_SHADE_TILE_OPAQUE)
 660          LP_COUNT(nr_pure_shade_opaque_64);
 661       else if (bin->head->cmd[0] == LP_RAST_OP_SHADE_TILE)
 662          LP_COUNT(nr_pure_shade_64);
 663    }
 664 }
 665
 666
 667 /* An empty bin is one that just loads the contents of the tile and
 668  * stores them again unchanged.  This typically happens when bins have
 669  * been flushed for some reason in the middle of a frame, or when
 670  * incremental updates are being made to a render target.
 671  *
 672  * Try to avoid doing pointless work in this case.
 673  */
 674 static boolean
 675 is_empty_bin( const struct cmd_bin *bin )
 676 {
 677    return bin->head == NULL;
 678 }
 679
 680
 681 /**
 682  * Rasterize/execute all bins within a scene.
 683  * Called per thread.
 684  */
 685 static void
 686 rasterize_scene(struct lp_rasterizer_task *task,
 687                 struct lp_scene *scene)
 688 {
 689    task->scene = scene;
 690    /* loop over scene bins, rasterize each */
 691 #if 0
 692    {
 693       unsigned i, j;
 694       for (i = 0; i < scene->tiles_x; i++) {
 695          for (j = 0; j < scene->tiles_y; j++) {
 696             struct cmd_bin *bin = lp_scene_get_bin(scene, i, j);
 697             rasterize_bin(task, bin, i, j);
 698          }
 699       }
 700    }
 701 #else
 702    {
 703       struct cmd_bin *bin;
 704
 705       assert(scene);
 706       while ((bin = lp_scene_bin_iter_next(scene))) {
 707          if (!is_empty_bin( bin ))
 708             rasterize_bin(task, bin);
 709       }
 710    }
 711 #endif
 712
 713    if (scene->fence) {
 714       lp_fence_signal(scene->fence);
 715    }
 716
 717    task->scene = NULL;
 718 }
 719
 720
 721 /**
 722  * Called by setup module when it has something for us to render.
 723  */
 724 void
 725 lp_rast_queue_scene( struct lp_rasterizer *rast,
 726                      struct lp_scene *scene)
 727 {
 728    LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
 729
 730    if (rast->num_threads == 0) {
 731       /* no threading */
 732
 733       lp_rast_begin( rast, scene );
 734
 735       rasterize_scene( &rast->tasks[0], scene );
 736
 737       lp_rast_end( rast );
 738
 739       rast->curr_scene = NULL;
 740    }
 741    else {
 742       /* threaded rendering! */
 743       unsigned i;
 744
 745       lp_scene_enqueue( rast->full_scenes, scene );
 746
 747       /* signal the threads that there's work to do */
 748       for (i = 0; i < rast->num_threads; i++) {
 749          pipe_semaphore_signal(&rast->tasks[i].work_ready);
 750       }
 751    }
 752
 753    LP_DBG(DEBUG_SETUP, "%s done \n", __FUNCTION__);
 754 }
 755
 756
 757 void
 758 lp_rast_finish( struct lp_rasterizer *rast )
 759 {
 760    if (rast->num_threads == 0) {
 761       /* nothing to do */
 762    }
 763    else {
 764       int i;
 765
 766       /* wait for work to complete */
 767       for (i = 0; i < rast->num_threads; i++) {
 768          pipe_semaphore_wait(&rast->tasks[i].work_done);
 769       }
 770    }
 771 }
 772
 773
 774 /**
 775  * This is the thread's main entrypoint.
 776  * It's a simple loop:
 777  *   1. wait for work
 778  *   2. do work
 779  *   3. signal that we're done
 780  */
 781 static PIPE_THREAD_ROUTINE( thread_func, init_data )
 782 {
 783    struct lp_rasterizer_task *task = (struct lp_rasterizer_task *) init_data;
 784    struct lp_rasterizer *rast = task->rast;
 785    boolean debug = false;
 786
 787    while (1) {
 788       /* wait for work */
 789       if (debug)
 790          debug_printf("thread %d waiting for work\n", task->thread_index);
 791       pipe_semaphore_wait(&task->work_ready);
 792
 793       if (rast->exit_flag)
 794          break;
 795
 796       if (task->thread_index == 0) {
 797          /* thread[0]:
 798           *  - get next scene to rasterize
 799           *  - map the framebuffer surfaces
 800           */
 801          lp_rast_begin( rast,
 802                         lp_scene_dequeue( rast->full_scenes, TRUE ) );
 803       }
 804
 805       /* Wait for all threads to get here so that threads[1+] don't
 806        * get a null rast->curr_scene pointer.
 807        */
 808       pipe_barrier_wait( &rast->barrier );
 809
 810       /* do work */
 811       if (debug)
 812          debug_printf("thread %d doing work\n", task->thread_index);
 813
 814       rasterize_scene(task,
 815                       rast->curr_scene);
 816
 817       /* wait for all threads to finish with this scene */
 818       pipe_barrier_wait( &rast->barrier );
 819
 820       /* XXX: shouldn't be necessary:
 821        */
 822       if (task->thread_index == 0) {
 823          lp_rast_end( rast );
 824       }
 825
 826       /* signal done with work */
 827       if (debug)
 828          debug_printf("thread %d done working\n", task->thread_index);
 829
 830       pipe_semaphore_signal(&task->work_done);
 831    }
 832
 833    return NULL;
 834 }
 835
 836
 837 /**
 838  * Initialize semaphores and spawn the threads.
 839  */
 840 static void
 841 create_rast_threads(struct lp_rasterizer *rast)
 842 {
 843    unsigned i;
 844
 845    /* NOTE: if num_threads is zero, we won't use any threads */
 846    for (i = 0; i < rast->num_threads; i++) {
 847       pipe_semaphore_init(&rast->tasks[i].work_ready, 0);
 848       pipe_semaphore_init(&rast->tasks[i].work_done, 0);
 849       rast->threads[i] = pipe_thread_create(thread_func,
 850                                             (void *) &rast->tasks[i]);
 851    }
 852 }
 853
 854
 855
 856 /**
 857  * Create new lp_rasterizer.  If num_threads is zero, don't create any
 858  * new threads, do rendering synchronously.
 859  * \param num_threads  number of rasterizer threads to create
 860  */
 861 struct lp_rasterizer *
 862 lp_rast_create( unsigned num_threads )
 863 {
 864    struct lp_rasterizer *rast;
 865    unsigned i;
 866
 867    rast = CALLOC_STRUCT(lp_rasterizer);
 868    if(!rast)
 869       return NULL;
 870
 871    rast->full_scenes = lp_scene_queue_create();
 872
 873    for (i = 0; i < Elements(rast->tasks); i++) {
 874       struct lp_rasterizer_task *task = &rast->tasks[i];
 875       task->rast = rast;
 876       task->thread_index = i;
 877    }
 878
 879    rast->num_threads = num_threads;
 880
 881    create_rast_threads(rast);
 882
 883    /* for synchronizing rasterization threads */
 884    pipe_barrier_init( &rast->barrier, rast->num_threads );
 885
 886    memset(lp_swizzled_cbuf, 0, sizeof lp_swizzled_cbuf);
 887
 888    memset(lp_dummy_tile, 0, sizeof lp_dummy_tile);
 889
 890    return rast;
 891 }
 892
 893
 894 /* Shutdown:
 895  */
 896 void lp_rast_destroy( struct lp_rasterizer *rast )
 897 {
 898    unsigned i;
 899
 900    /* Set exit_flag and signal each thread's work_ready semaphore.
 901     * Each thread will be woken up, notice that the exit_flag is set and
 902     * break out of its main loop.  The thread will then exit.
 903     */
 904    rast->exit_flag = TRUE;
 905    for (i = 0; i < rast->num_threads; i++) {
 906       pipe_semaphore_signal(&rast->tasks[i].work_ready);
 907    }
 908
 909    /* Wait for threads to terminate before cleaning up per-thread data */
 910    for (i = 0; i < rast->num_threads; i++) {
 911       pipe_thread_wait(rast->threads[i]);
 912    }
 913
 914    /* Clean up per-thread data */
 915    for (i = 0; i < rast->num_threads; i++) {
 916       pipe_semaphore_destroy(&rast->tasks[i].work_ready);
 917       pipe_semaphore_destroy(&rast->tasks[i].work_done);
 918    }
 919
 920    /* for synchronizing rasterization threads */
 921    pipe_barrier_destroy( &rast->barrier );
 922
 923    lp_scene_queue_destroy(rast->full_scenes);
 924
 925    FREE(rast);
 926 }
 927
 928
 929 /** Return number of rasterization threads */
 930 unsigned
 931 lp_rast_get_num_threads( struct lp_rasterizer *rast )
 932 {
 933    return rast->num_threads;
 934 }
 935
 936