lp_rast.c revision db2b6ca504e5046697e3d9262cfd401b8a4971fd 
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
48int jit_line = 0;
49const struct lp_rast_state *jit_state = NULL;
50const 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 */
58static void
59lp_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
72static void
73lp_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 */
92static void
93lp_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 */
148static void
149lp_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 */
210static void
211lp_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 area 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 */
301static void
302lp_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 */
331static void
332lp_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;
338   struct lp_fragment_shader_variant *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   state = task->state;
350   assert(state);
351   if (!state) {
352      return;
353   }
354   variant = state->variant;
355
356   /* render the whole 64x64 tile in 4x4 chunks */
357   for (y = 0; y < TILE_SIZE; y += 4){
358      for (x = 0; x < TILE_SIZE; x += 4) {
359         uint8_t *color[PIPE_MAX_COLOR_BUFS];
360         uint32_t *depth;
361         unsigned i;
362
363         /* color buffer */
364         for (i = 0; i < scene->fb.nr_cbufs; i++)
365            color[i] = lp_rast_get_color_block_pointer(task, i,
366                                                       tile_x + x, tile_y + y);
367
368         /* depth buffer */
369         depth = lp_rast_get_depth_block_pointer(task, tile_x + x, tile_y + y);
370
371         /* run shader on 4x4 block */
372         BEGIN_JIT_CALL(state, task);
373         variant->jit_function[RAST_WHOLE]( &state->jit_context,
374                                            tile_x + x, tile_y + y,
375                                            inputs->frontfacing,
376                                            GET_A0(inputs),
377                                            GET_DADX(inputs),
378                                            GET_DADY(inputs),
379                                            color,
380                                            depth,
381                                            0xffff,
382                                            &task->vis_counter);
383         END_JIT_CALL();
384      }
385   }
386}
387
388
389/**
390 * Run the shader on all blocks in a tile.  This is used when a tile is
391 * completely contained inside a triangle, and the shader is opaque.
392 * This is a bin command called during bin processing.
393 */
394static void
395lp_rast_shade_tile_opaque(struct lp_rasterizer_task *task,
396                          const union lp_rast_cmd_arg arg)
397{
398   const struct lp_scene *scene = task->scene;
399   unsigned i;
400
401   LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
402
403   assert(task->state);
404   if (!task->state) {
405      return;
406   }
407
408   /* this will prevent converting the layout from tiled to linear */
409   for (i = 0; i < scene->fb.nr_cbufs; i++) {
410      (void)lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL);
411   }
412
413   lp_rast_shade_tile(task, arg);
414}
415
416
417/**
418 * Compute shading for a 4x4 block of pixels inside a triangle.
419 * This is a bin command called during bin processing.
420 * \param x  X position of quad in window coords
421 * \param y  Y position of quad in window coords
422 */
423void
424lp_rast_shade_quads_mask(struct lp_rasterizer_task *task,
425                         const struct lp_rast_shader_inputs *inputs,
426                         unsigned x, unsigned y,
427                         unsigned mask)
428{
429   const struct lp_rast_state *state = task->state;
430   struct lp_fragment_shader_variant *variant = state->variant;
431   const struct lp_scene *scene = task->scene;
432   uint8_t *color[PIPE_MAX_COLOR_BUFS];
433   void *depth;
434   unsigned i;
435
436   assert(state);
437
438   /* Sanity checks */
439   assert(x < scene->tiles_x * TILE_SIZE);
440   assert(y < scene->tiles_y * TILE_SIZE);
441   assert(x % TILE_VECTOR_WIDTH == 0);
442   assert(y % TILE_VECTOR_HEIGHT == 0);
443
444   assert((x % 4) == 0);
445   assert((y % 4) == 0);
446
447   /* color buffer */
448   for (i = 0; i < scene->fb.nr_cbufs; i++) {
449      color[i] = lp_rast_get_color_block_pointer(task, i, x, y);
450      assert(lp_check_alignment(color[i], 16));
451   }
452
453   /* depth buffer */
454   depth = lp_rast_get_depth_block_pointer(task, x, y);
455
456
457   assert(lp_check_alignment(state->jit_context.blend_color, 16));
458
459   /* run shader on 4x4 block */
460   BEGIN_JIT_CALL(state, task);
461   variant->jit_function[RAST_EDGE_TEST](&state->jit_context,
462                                         x, y,
463                                         inputs->frontfacing,
464                                         GET_A0(inputs),
465                                         GET_DADX(inputs),
466                                         GET_DADY(inputs),
467                                         color,
468                                         depth,
469                                         mask,
470                                         &task->vis_counter);
471   END_JIT_CALL();
472}
473
474
475
476/**
477 * Begin a new occlusion query.
478 * This is a bin command put in all bins.
479 * Called per thread.
480 */
481static void
482lp_rast_begin_query(struct lp_rasterizer_task *task,
483                    const union lp_rast_cmd_arg arg)
484{
485   struct llvmpipe_query *pq = arg.query_obj;
486
487   assert(task->query == NULL);
488   task->vis_counter = 0;
489   task->query = pq;
490}
491
492
493/**
494 * End the current occlusion query.
495 * This is a bin command put in all bins.
496 * Called per thread.
497 */
498static void
499lp_rast_end_query(struct lp_rasterizer_task *task,
500                  const union lp_rast_cmd_arg arg)
501{
502   assert(task->query);
503   if (task->query) {
504      task->query->count[task->thread_index] += task->vis_counter;
505      task->query = NULL;
506   }
507}
508
509
510void
511lp_rast_set_state(struct lp_rasterizer_task *task,
512                  const union lp_rast_cmd_arg arg)
513{
514   task->state = arg.state;
515}
516
517
518
519/**
520 * Set top row and left column of the tile's pixels to white.  For debugging.
521 */
522static void
523outline_tile(uint8_t *tile)
524{
525   const uint8_t val = 0xff;
526   unsigned i;
527
528   for (i = 0; i < TILE_SIZE; i++) {
529      TILE_PIXEL(tile, i, 0, 0) = val;
530      TILE_PIXEL(tile, i, 0, 1) = val;
531      TILE_PIXEL(tile, i, 0, 2) = val;
532      TILE_PIXEL(tile, i, 0, 3) = val;
533
534      TILE_PIXEL(tile, 0, i, 0) = val;
535      TILE_PIXEL(tile, 0, i, 1) = val;
536      TILE_PIXEL(tile, 0, i, 2) = val;
537      TILE_PIXEL(tile, 0, i, 3) = val;
538   }
539}
540
541
542/**
543 * Draw grid of gray lines at 16-pixel intervals across the tile to
544 * show the sub-tile boundaries.  For debugging.
545 */
546static void
547outline_subtiles(uint8_t *tile)
548{
549   const uint8_t val = 0x80;
550   const unsigned step = 16;
551   unsigned i, j;
552
553   for (i = 0; i < TILE_SIZE; i += step) {
554      for (j = 0; j < TILE_SIZE; j++) {
555         TILE_PIXEL(tile, i, j, 0) = val;
556         TILE_PIXEL(tile, i, j, 1) = val;
557         TILE_PIXEL(tile, i, j, 2) = val;
558         TILE_PIXEL(tile, i, j, 3) = val;
559
560         TILE_PIXEL(tile, j, i, 0) = val;
561         TILE_PIXEL(tile, j, i, 1) = val;
562         TILE_PIXEL(tile, j, i, 2) = val;
563         TILE_PIXEL(tile, j, i, 3) = val;
564      }
565   }
566
567   outline_tile(tile);
568}
569
570
571
572/**
573 * Called when we're done writing to a color tile.
574 */
575static void
576lp_rast_tile_end(struct lp_rasterizer_task *task)
577{
578#ifdef DEBUG
579   if (LP_DEBUG & (DEBUG_SHOW_SUBTILES | DEBUG_SHOW_TILES)) {
580      const struct lp_scene *scene = task->scene;
581      unsigned buf;
582
583      for (buf = 0; buf < scene->fb.nr_cbufs; buf++) {
584         uint8_t *color = lp_rast_get_color_block_pointer(task, buf,
585                                                          task->x, task->y);
586
587         if (LP_DEBUG & DEBUG_SHOW_SUBTILES)
588            outline_subtiles(color);
589         else if (LP_DEBUG & DEBUG_SHOW_TILES)
590            outline_tile(color);
591      }
592   }
593#else
594   (void) outline_subtiles;
595#endif
596
597   lp_rast_store_linear_color(task);
598
599   if (task->query) {
600      union lp_rast_cmd_arg dummy = {0};
601      lp_rast_end_query(task, dummy);
602   }
603
604   /* debug */
605   memset(task->color_tiles, 0, sizeof(task->color_tiles));
606   task->depth_tile = NULL;
607
608   task->bin = NULL;
609}
610
611static lp_rast_cmd_func dispatch[LP_RAST_OP_MAX] =
612{
613   lp_rast_clear_color,
614   lp_rast_clear_zstencil,
615   lp_rast_triangle_1,
616   lp_rast_triangle_2,
617   lp_rast_triangle_3,
618   lp_rast_triangle_4,
619   lp_rast_triangle_5,
620   lp_rast_triangle_6,
621   lp_rast_triangle_7,
622   lp_rast_triangle_8,
623   lp_rast_triangle_3_4,
624   lp_rast_triangle_3_16,
625   lp_rast_triangle_4_16,
626   lp_rast_shade_tile,
627   lp_rast_shade_tile_opaque,
628   lp_rast_begin_query,
629   lp_rast_end_query,
630   lp_rast_set_state,
631};
632
633
634static void
635do_rasterize_bin(struct lp_rasterizer_task *task,
636                 const struct cmd_bin *bin)
637{
638   const struct cmd_block *block;
639   unsigned k;
640
641   if (0)
642      lp_debug_bin(bin);
643
644   for (block = bin->head; block; block = block->next) {
645      for (k = 0; k < block->count; k++) {
646         dispatch[block->cmd[k]]( task, block->arg[k] );
647      }
648   }
649}
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 */
659static void
660rasterize_bin(struct lp_rasterizer_task *task,
661              const struct cmd_bin *bin )
662{
663   lp_rast_tile_begin( task, bin );
664
665   do_rasterize_bin(task, bin);
666
667   lp_rast_tile_end(task);
668
669
670   /* Debug/Perf flags:
671    */
672   if (bin->head->count == 1) {
673      if (bin->head->cmd[0] == LP_RAST_OP_SHADE_TILE_OPAQUE)
674         LP_COUNT(nr_pure_shade_opaque_64);
675      else if (bin->head->cmd[0] == LP_RAST_OP_SHADE_TILE)
676         LP_COUNT(nr_pure_shade_64);
677   }
678}
679
680
681/* An empty bin is one that just loads the contents of the tile and
682 * stores them again unchanged.  This typically happens when bins have
683 * been flushed for some reason in the middle of a frame, or when
684 * incremental updates are being made to a render target.
685 *
686 * Try to avoid doing pointless work in this case.
687 */
688static boolean
689is_empty_bin( const struct cmd_bin *bin )
690{
691   return bin->head == NULL;
692}
693
694
695/**
696 * Rasterize/execute all bins within a scene.
697 * Called per thread.
698 */
699static void
700rasterize_scene(struct lp_rasterizer_task *task,
701                struct lp_scene *scene)
702{
703   task->scene = scene;
704
705   if (!task->rast->no_rast) {
706      /* loop over scene bins, rasterize each */
707#if 0
708      {
709         unsigned i, j;
710         for (i = 0; i < scene->tiles_x; i++) {
711            for (j = 0; j < scene->tiles_y; j++) {
712               struct cmd_bin *bin = lp_scene_get_bin(scene, i, j);
713               rasterize_bin(task, bin, i, j);
714            }
715         }
716      }
717#else
718      {
719         struct cmd_bin *bin;
720
721         assert(scene);
722         while ((bin = lp_scene_bin_iter_next(scene))) {
723            if (!is_empty_bin( bin ))
724               rasterize_bin(task, bin);
725         }
726      }
727#endif
728   }
729
730
731   if (scene->fence) {
732      lp_fence_signal(scene->fence);
733   }
734
735   task->scene = NULL;
736}
737
738
739/**
740 * Called by setup module when it has something for us to render.
741 */
742void
743lp_rast_queue_scene( struct lp_rasterizer *rast,
744                     struct lp_scene *scene)
745{
746   LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
747
748   if (rast->num_threads == 0) {
749      /* no threading */
750
751      lp_rast_begin( rast, scene );
752
753      rasterize_scene( &rast->tasks[0], scene );
754
755      lp_rast_end( rast );
756
757      rast->curr_scene = NULL;
758   }
759   else {
760      /* threaded rendering! */
761      unsigned i;
762
763      lp_scene_enqueue( rast->full_scenes, scene );
764
765      /* signal the threads that there's work to do */
766      for (i = 0; i < rast->num_threads; i++) {
767         pipe_semaphore_signal(&rast->tasks[i].work_ready);
768      }
769   }
770
771   LP_DBG(DEBUG_SETUP, "%s done \n", __FUNCTION__);
772}
773
774
775void
776lp_rast_finish( struct lp_rasterizer *rast )
777{
778   if (rast->num_threads == 0) {
779      /* nothing to do */
780   }
781   else {
782      int i;
783
784      /* wait for work to complete */
785      for (i = 0; i < rast->num_threads; i++) {
786         pipe_semaphore_wait(&rast->tasks[i].work_done);
787      }
788   }
789}
790
791
792/**
793 * This is the thread's main entrypoint.
794 * It's a simple loop:
795 *   1. wait for work
796 *   2. do work
797 *   3. signal that we're done
798 */
799static PIPE_THREAD_ROUTINE( thread_function, init_data )
800{
801   struct lp_rasterizer_task *task = (struct lp_rasterizer_task *) init_data;
802   struct lp_rasterizer *rast = task->rast;
803   boolean debug = false;
804
805   while (1) {
806      /* wait for work */
807      if (debug)
808         debug_printf("thread %d waiting for work\n", task->thread_index);
809      pipe_semaphore_wait(&task->work_ready);
810
811      if (rast->exit_flag)
812         break;
813
814      if (task->thread_index == 0) {
815         /* thread[0]:
816          *  - get next scene to rasterize
817          *  - map the framebuffer surfaces
818          */
819         lp_rast_begin( rast,
820                        lp_scene_dequeue( rast->full_scenes, TRUE ) );
821      }
822
823      /* Wait for all threads to get here so that threads[1+] don't
824       * get a null rast->curr_scene pointer.
825       */
826      pipe_barrier_wait( &rast->barrier );
827
828      /* do work */
829      if (debug)
830         debug_printf("thread %d doing work\n", task->thread_index);
831
832      rasterize_scene(task,
833                      rast->curr_scene);
834
835      /* wait for all threads to finish with this scene */
836      pipe_barrier_wait( &rast->barrier );
837
838      /* XXX: shouldn't be necessary:
839       */
840      if (task->thread_index == 0) {
841         lp_rast_end( rast );
842      }
843
844      /* signal done with work */
845      if (debug)
846         debug_printf("thread %d done working\n", task->thread_index);
847
848      pipe_semaphore_signal(&task->work_done);
849   }
850
851   return NULL;
852}
853
854
855/**
856 * Initialize semaphores and spawn the threads.
857 */
858static void
859create_rast_threads(struct lp_rasterizer *rast)
860{
861   unsigned i;
862
863   /* NOTE: if num_threads is zero, we won't use any threads */
864   for (i = 0; i < rast->num_threads; i++) {
865      pipe_semaphore_init(&rast->tasks[i].work_ready, 0);
866      pipe_semaphore_init(&rast->tasks[i].work_done, 0);
867      rast->threads[i] = pipe_thread_create(thread_function,
868                                            (void *) &rast->tasks[i]);
869   }
870}
871
872
873
874/**
875 * Create new lp_rasterizer.  If num_threads is zero, don't create any
876 * new threads, do rendering synchronously.
877 * \param num_threads  number of rasterizer threads to create
878 */
879struct lp_rasterizer *
880lp_rast_create( unsigned num_threads )
881{
882   struct lp_rasterizer *rast;
883   unsigned i;
884
885   rast = CALLOC_STRUCT(lp_rasterizer);
886   if (!rast) {
887      goto no_rast;
888   }
889
890   rast->full_scenes = lp_scene_queue_create();
891   if (!rast->full_scenes) {
892      goto no_full_scenes;
893   }
894
895   for (i = 0; i < Elements(rast->tasks); i++) {
896      struct lp_rasterizer_task *task = &rast->tasks[i];
897      task->rast = rast;
898      task->thread_index = i;
899   }
900
901   rast->num_threads = num_threads;
902
903   rast->no_rast = debug_get_bool_option("LP_NO_RAST", FALSE);
904
905   create_rast_threads(rast);
906
907   /* for synchronizing rasterization threads */
908   pipe_barrier_init( &rast->barrier, rast->num_threads );
909
910   memset(lp_swizzled_cbuf, 0, sizeof lp_swizzled_cbuf);
911
912   memset(lp_dummy_tile, 0, sizeof lp_dummy_tile);
913
914   return rast;
915
916no_full_scenes:
917   FREE(rast);
918no_rast:
919   return NULL;
920}
921
922
923/* Shutdown:
924 */
925void lp_rast_destroy( struct lp_rasterizer *rast )
926{
927   unsigned i;
928
929   /* Set exit_flag and signal each thread's work_ready semaphore.
930    * Each thread will be woken up, notice that the exit_flag is set and
931    * break out of its main loop.  The thread will then exit.
932    */
933   rast->exit_flag = TRUE;
934   for (i = 0; i < rast->num_threads; i++) {
935      pipe_semaphore_signal(&rast->tasks[i].work_ready);
936   }
937
938   /* Wait for threads to terminate before cleaning up per-thread data */
939   for (i = 0; i < rast->num_threads; i++) {
940      pipe_thread_wait(rast->threads[i]);
941   }
942
943   /* Clean up per-thread data */
944   for (i = 0; i < rast->num_threads; i++) {
945      pipe_semaphore_destroy(&rast->tasks[i].work_ready);
946      pipe_semaphore_destroy(&rast->tasks[i].work_done);
947   }
948
949   /* for synchronizing rasterization threads */
950   pipe_barrier_destroy( &rast->barrier );
951
952   lp_scene_queue_destroy(rast->full_scenes);
953
954   FREE(rast);
955}
956
957
958/** Return number of rasterization threads */
959unsigned
960lp_rast_get_num_threads( struct lp_rasterizer *rast )
961{
962   return rast->num_threads;
963}
964
965
966