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