X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fllvmpipe%2Flp_rast.c;h=e168766e348f88e27b4c8753b4e42d2a45fb7a3b;hb=6f7371619c5edcde647ae8f4822d1b5bae050ef6;hp=ce6896d16e4dd4ff288ca8f62a58b227ae4f60b0;hpb=18452c1e87f79327fbd5f27478028b481ee72a5d;p=mesa.git diff --git a/src/gallium/drivers/llvmpipe/lp_rast.c b/src/gallium/drivers/llvmpipe/lp_rast.c index ce6896d16e4..e168766e348 100644 --- a/src/gallium/drivers/llvmpipe/lp_rast.c +++ b/src/gallium/drivers/llvmpipe/lp_rast.c @@ -30,22 +30,27 @@ #include "util/u_math.h" #include "util/u_rect.h" #include "util/u_surface.h" +#include "util/u_pack_color.h" + +#include "os/os_time.h" #include "lp_scene_queue.h" +#include "lp_context.h" #include "lp_debug.h" #include "lp_fence.h" #include "lp_perf.h" #include "lp_query.h" #include "lp_rast.h" #include "lp_rast_priv.h" -#include "lp_tile_soa.h" #include "gallivm/lp_bld_debug.h" #include "lp_scene.h" +#include "lp_tex_sample.h" #ifdef DEBUG int jit_line = 0; const struct lp_rast_state *jit_state = NULL; +const struct lp_rasterizer_task *jit_task = NULL; #endif @@ -57,39 +62,11 @@ static void lp_rast_begin( struct lp_rasterizer *rast, struct lp_scene *scene ) { - const struct pipe_framebuffer_state *fb = &scene->fb; - int i; - rast->curr_scene = scene; LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__); - rast->state.nr_cbufs = scene->fb.nr_cbufs; - - for (i = 0; i < rast->state.nr_cbufs; i++) { - struct pipe_surface *cbuf = scene->fb.cbufs[i]; - llvmpipe_resource_map(cbuf->texture, - cbuf->face, - cbuf->level, - cbuf->zslice, - LP_TEX_USAGE_READ_WRITE, - LP_TEX_LAYOUT_LINEAR); - } - - if (fb->zsbuf) { - struct pipe_surface *zsbuf = scene->fb.zsbuf; - rast->zsbuf.stride = llvmpipe_resource_stride(zsbuf->texture, zsbuf->level); - rast->zsbuf.blocksize = - util_format_get_blocksize(zsbuf->texture->format); - - rast->zsbuf.map = llvmpipe_resource_map(zsbuf->texture, - zsbuf->face, - zsbuf->level, - zsbuf->zslice, - LP_TEX_USAGE_READ_WRITE, - LP_TEX_LAYOUT_NONE); - } - + lp_scene_begin_rasterization( scene ); lp_scene_bin_iter_begin( scene ); } @@ -97,37 +74,9 @@ lp_rast_begin( struct lp_rasterizer *rast, static void lp_rast_end( struct lp_rasterizer *rast ) { - struct lp_scene *scene = rast->curr_scene; - unsigned i; - - /* Unmap color buffers */ - for (i = 0; i < rast->state.nr_cbufs; i++) { - struct pipe_surface *cbuf = scene->fb.cbufs[i]; - llvmpipe_resource_unmap(cbuf->texture, - cbuf->face, - cbuf->level, - cbuf->zslice); - } - - /* Unmap z/stencil buffer */ - if (rast->zsbuf.map) { - struct pipe_surface *zsbuf = scene->fb.zsbuf; - llvmpipe_resource_unmap(zsbuf->texture, - zsbuf->face, - zsbuf->level, - zsbuf->zslice); - rast->zsbuf.map = NULL; - } - - lp_scene_reset( rast->curr_scene ); + lp_scene_end_rasterization( rast->curr_scene ); rast->curr_scene = NULL; - -#ifdef DEBUG - if (0) - debug_printf("Post render scene: tile unswizzle: %u tile swizzle: %u\n", - lp_tile_unswizzle_count, lp_tile_swizzle_count); -#endif } @@ -138,110 +87,70 @@ lp_rast_end( struct lp_rasterizer *rast ) */ static void lp_rast_tile_begin(struct lp_rasterizer_task *task, - unsigned x, unsigned y) + const struct cmd_bin *bin, + int x, int y) { - struct lp_rasterizer *rast = task->rast; - struct lp_scene *scene = rast->curr_scene; - enum lp_texture_usage usage; - LP_DBG(DEBUG_RAST, "%s %d,%d\n", __FUNCTION__, x, y); - assert(x % TILE_SIZE == 0); - assert(y % TILE_SIZE == 0); + task->bin = bin; + task->x = x * TILE_SIZE; + task->y = y * TILE_SIZE; + task->width = TILE_SIZE + x * TILE_SIZE > task->scene->fb.width ? + task->scene->fb.width - x * TILE_SIZE : TILE_SIZE; + task->height = TILE_SIZE + y * TILE_SIZE > task->scene->fb.height ? + task->scene->fb.height - y * TILE_SIZE : TILE_SIZE; - task->x = x; - task->y = y; + task->thread_data.vis_counter = 0; + task->ps_invocations = 0; - /* reset pointers to color tile(s) */ + /* reset pointers to color and depth tile(s) */ memset(task->color_tiles, 0, sizeof(task->color_tiles)); - - /* get pointer to depth/stencil tile */ - { - struct pipe_surface *zsbuf = rast->curr_scene->fb.zsbuf; - if (zsbuf) { - struct llvmpipe_resource *lpt = llvmpipe_resource(zsbuf->texture); - - if (scene->has_depthstencil_clear) - usage = LP_TEX_USAGE_WRITE_ALL; - else - usage = LP_TEX_USAGE_READ_WRITE; - - /* "prime" the tile: convert data from linear to tiled if necessary - * and update the tile's layout info. - */ - (void) llvmpipe_get_texture_tile(lpt, - zsbuf->face + zsbuf->zslice, - zsbuf->level, - usage, - x, y); - /* Get actual pointer to the tile data. Note that depth/stencil - * data is tiled differently than color data. - */ - task->depth_tile = lp_rast_get_depth_block_pointer(task, x, y); - - assert(task->depth_tile); - } - else { - task->depth_tile = NULL; - } - } + task->depth_tile = NULL; } /** * Clear the rasterizer's current color tile. * This is a bin command called during bin processing. + * Clear commands always clear all bound layers. */ -void +static void lp_rast_clear_color(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { - struct lp_rasterizer *rast = task->rast; - const uint8_t *clear_color = arg.clear_color; + const struct lp_scene *scene = task->scene; + unsigned cbuf = arg.clear_rb->cbuf; + union util_color uc; + enum pipe_format format; - unsigned i; + /* we never bin clear commands for non-existing buffers */ + assert(cbuf < scene->fb.nr_cbufs); + assert(scene->fb.cbufs[cbuf]); - LP_DBG(DEBUG_RAST, "%s 0x%x,0x%x,0x%x,0x%x\n", __FUNCTION__, - clear_color[0], - clear_color[1], - clear_color[2], - clear_color[3]); - - if (clear_color[0] == clear_color[1] && - clear_color[1] == clear_color[2] && - clear_color[2] == clear_color[3]) { - /* clear to grayscale value {x, x, x, x} */ - for (i = 0; i < rast->state.nr_cbufs; i++) { - uint8_t *ptr = - lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL); - memset(ptr, clear_color[0], TILE_SIZE * TILE_SIZE * 4); - } - } - else { - /* Non-gray color. - * Note: if the swizzled tile layout changes (see TILE_PIXEL) this code - * will need to change. It'll be pretty obvious when clearing no longer - * works. - */ - const unsigned chunk = TILE_SIZE / 4; - for (i = 0; i < rast->state.nr_cbufs; i++) { - uint8_t *c = - lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL); - unsigned j; - - for (j = 0; j < 4 * TILE_SIZE; j++) { - memset(c, clear_color[0], chunk); - c += chunk; - memset(c, clear_color[1], chunk); - c += chunk; - memset(c, clear_color[2], chunk); - c += chunk; - memset(c, clear_color[3], chunk); - c += chunk; - } - } - } + format = scene->fb.cbufs[cbuf]->format; + uc = arg.clear_rb->color_val; + /* + * this is pretty rough since we have target format (bunch of bytes...) here. + * dump it as raw 4 dwords. + */ + LP_DBG(DEBUG_RAST, "%s clear value (target format %d) raw 0x%x,0x%x,0x%x,0x%x\n", + __FUNCTION__, format, uc.ui[0], uc.ui[1], uc.ui[2], uc.ui[3]); + + + util_fill_box(scene->cbufs[cbuf].map, + format, + scene->cbufs[cbuf].stride, + scene->cbufs[cbuf].layer_stride, + task->x, + task->y, + 0, + task->width, + task->height, + scene->fb_max_layer + 1, + &uc); + + /* this will increase for each rb which probably doesn't mean much */ LP_COUNT(nr_color_tile_clear); } @@ -249,106 +158,114 @@ lp_rast_clear_color(struct lp_rasterizer_task *task, /** * Clear the rasterizer's current z/stencil tile. * This is a bin command called during bin processing. + * Clear commands always clear all bound layers. */ -void +static void lp_rast_clear_zstencil(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { - struct lp_rasterizer *rast = task->rast; - const struct lp_rast_clearzs *clearzs = arg.clear_zstencil; - unsigned clear_value = clearzs->clearzs_value; - unsigned clear_mask = clearzs->clearzs_mask; - const unsigned height = TILE_SIZE / TILE_VECTOR_HEIGHT; - const unsigned width = TILE_SIZE * TILE_VECTOR_HEIGHT; - const unsigned block_size = rast->zsbuf.blocksize; - const unsigned dst_stride = rast->zsbuf.stride * TILE_VECTOR_HEIGHT; + const struct lp_scene *scene = task->scene; + uint64_t clear_value64 = arg.clear_zstencil.value; + uint64_t clear_mask64 = arg.clear_zstencil.mask; + uint32_t clear_value = (uint32_t) clear_value64; + uint32_t clear_mask = (uint32_t) clear_mask64; + const unsigned height = task->height; + const unsigned width = task->width; + const unsigned dst_stride = scene->zsbuf.stride; uint8_t *dst; unsigned i, j; + unsigned block_size; - LP_DBG(DEBUG_RAST, "%s 0x%x%x\n", __FUNCTION__, clear_value, clear_mask); + LP_DBG(DEBUG_RAST, "%s: value=0x%08x, mask=0x%08x\n", + __FUNCTION__, clear_value, clear_mask); /* - * Clear the aera of the swizzled depth/depth buffer matching this tile, in - * stripes of TILE_VECTOR_HEIGHT x TILE_SIZE at a time. - * - * The swizzled depth format is such that the depths for - * TILE_VECTOR_HEIGHT x TILE_VECTOR_WIDTH pixels have consecutive offsets. + * Clear the area of the depth/depth buffer matching this tile. */ - dst = task->depth_tile; - - switch (block_size) { - case 1: - memset(dst, (uint8_t) clear_value, height * width); - break; - case 2: - for (i = 0; i < height; i++) { - uint16_t *row = (uint16_t *)dst; - for (j = 0; j < width; j++) - *row++ = (uint16_t) clear_value; - dst += dst_stride; - } - break; - case 4: - if (clear_mask == 0xffffffff) { - for (i = 0; i < height; i++) { - uint32_t *row = (uint32_t *)dst; - for (j = 0; j < width; j++) - *row++ = clear_value; - dst += dst_stride; - } - } - else { - for (i = 0; i < height; i++) { - uint32_t *row = (uint32_t *)dst; - for (j = 0; j < width; j++) { - uint32_t tmp = ~clear_mask & *row; - *row++ = (clear_value & clear_mask) | tmp; - } - dst += dst_stride; - } - } - break; - default: - assert(0); - break; - } -} + if (scene->fb.zsbuf) { + unsigned layer; + uint8_t *dst_layer = lp_rast_get_depth_tile_pointer(task, LP_TEX_USAGE_READ_WRITE); + block_size = util_format_get_blocksize(scene->fb.zsbuf->format); + clear_value &= clear_mask; + for (layer = 0; layer <= scene->fb_max_layer; layer++) { + dst = dst_layer; + switch (block_size) { + case 1: + assert(clear_mask == 0xff); + memset(dst, (uint8_t) clear_value, height * width); + break; + case 2: + if (clear_mask == 0xffff) { + for (i = 0; i < height; i++) { + uint16_t *row = (uint16_t *)dst; + for (j = 0; j < width; j++) + *row++ = (uint16_t) clear_value; + dst += dst_stride; + } + } + else { + for (i = 0; i < height; i++) { + uint16_t *row = (uint16_t *)dst; + for (j = 0; j < width; j++) { + uint16_t tmp = ~clear_mask & *row; + *row++ = clear_value | tmp; + } + dst += dst_stride; + } + } + break; + case 4: + if (clear_mask == 0xffffffff) { + for (i = 0; i < height; i++) { + uint32_t *row = (uint32_t *)dst; + for (j = 0; j < width; j++) + *row++ = clear_value; + dst += dst_stride; + } + } + else { + for (i = 0; i < height; i++) { + uint32_t *row = (uint32_t *)dst; + for (j = 0; j < width; j++) { + uint32_t tmp = ~clear_mask & *row; + *row++ = clear_value | tmp; + } + dst += dst_stride; + } + } + break; + case 8: + clear_value64 &= clear_mask64; + if (clear_mask64 == 0xffffffffffULL) { + for (i = 0; i < height; i++) { + uint64_t *row = (uint64_t *)dst; + for (j = 0; j < width; j++) + *row++ = clear_value64; + dst += dst_stride; + } + } + else { + for (i = 0; i < height; i++) { + uint64_t *row = (uint64_t *)dst; + for (j = 0; j < width; j++) { + uint64_t tmp = ~clear_mask64 & *row; + *row++ = clear_value64 | tmp; + } + dst += dst_stride; + } + } + break; -/** - * Convert the color tile from tiled to linear layout. - * This is generally only done when we're flushing the scene just prior to - * SwapBuffers. If we didn't do this here, we'd have to convert the entire - * tiled color buffer to linear layout in the llvmpipe_texture_unmap() - * function. It's better to do it here to take advantage of - * threading/parallelism. - * This is a bin command which is stored in all bins. - */ -void -lp_rast_store_linear_color( struct lp_rasterizer_task *task, - const union lp_rast_cmd_arg arg) -{ - struct lp_rasterizer *rast = task->rast; - struct lp_scene *scene = rast->curr_scene; - unsigned buf; - - for (buf = 0; buf < rast->state.nr_cbufs; buf++) { - struct pipe_surface *cbuf = scene->fb.cbufs[buf]; - const unsigned face_slice = cbuf->face + cbuf->zslice; - const unsigned level = cbuf->level; - struct llvmpipe_resource *lpt = llvmpipe_resource(cbuf->texture); - - if (!task->color_tiles[buf]) - continue; - - llvmpipe_unswizzle_cbuf_tile(lpt, - face_slice, - level, - task->x, task->y, - task->color_tiles[buf]); + default: + assert(0); + break; + } + dst_layer += scene->zsbuf.layer_stride; + } } } @@ -359,46 +276,77 @@ lp_rast_store_linear_color( struct lp_rasterizer_task *task, * completely contained inside a triangle. * This is a bin command called during bin processing. */ -void +static void lp_rast_shade_tile(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { - struct lp_rasterizer *rast = task->rast; + const struct lp_scene *scene = task->scene; const struct lp_rast_shader_inputs *inputs = arg.shade_tile; - const struct lp_rast_state *state = inputs->state; - struct lp_fragment_shader_variant *variant = state->variant; + const struct lp_rast_state *state; + struct lp_fragment_shader_variant *variant; const unsigned tile_x = task->x, tile_y = task->y; unsigned x, y; + if (inputs->disable) { + /* This command was partially binned and has been disabled */ + return; + } + LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__); + state = task->state; + assert(state); + if (!state) { + return; + } + variant = state->variant; + /* render the whole 64x64 tile in 4x4 chunks */ - for (y = 0; y < TILE_SIZE; y += 4){ - for (x = 0; x < TILE_SIZE; x += 4) { + for (y = 0; y < task->height; y += 4){ + for (x = 0; x < task->width; x += 4) { uint8_t *color[PIPE_MAX_COLOR_BUFS]; - uint32_t *depth; + unsigned stride[PIPE_MAX_COLOR_BUFS]; + uint8_t *depth = NULL; + unsigned depth_stride = 0; unsigned i; /* color buffer */ - for (i = 0; i < rast->state.nr_cbufs; i++) - color[i] = lp_rast_get_color_block_pointer(task, i, - tile_x + x, tile_y + y); + for (i = 0; i < scene->fb.nr_cbufs; i++){ + if (scene->fb.cbufs[i]) { + stride[i] = scene->cbufs[i].stride; + color[i] = lp_rast_get_color_block_pointer(task, i, tile_x + x, + tile_y + y, inputs->layer); + } + else { + stride[i] = 0; + color[i] = NULL; + } + } /* depth buffer */ - depth = lp_rast_get_depth_block_pointer(task, tile_x + x, tile_y + y); + if (scene->zsbuf.map) { + depth = lp_rast_get_depth_block_pointer(task, tile_x + x, + tile_y + y, inputs->layer); + depth_stride = scene->zsbuf.stride; + } + + /* Propagate non-interpolated raster state. */ + task->thread_data.raster_state.viewport_index = inputs->viewport_index; /* run shader on 4x4 block */ - BEGIN_JIT_CALL(state); + BEGIN_JIT_CALL(state, task); variant->jit_function[RAST_WHOLE]( &state->jit_context, tile_x + x, tile_y + y, - inputs->facing, - inputs->a0, - inputs->dadx, - inputs->dady, + inputs->frontfacing, + GET_A0(inputs), + GET_DADX(inputs), + GET_DADY(inputs), color, depth, 0xffff, - &task->vis_counter); + &task->thread_data, + stride, + depth_stride); END_JIT_CALL(); } } @@ -410,18 +358,15 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task, * completely contained inside a triangle, and the shader is opaque. * This is a bin command called during bin processing. */ -void +static void lp_rast_shade_tile_opaque(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { - struct lp_rasterizer *rast = task->rast; - unsigned i; - LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__); - /* this will prevent converting the layout from tiled to linear */ - for (i = 0; i < rast->state.nr_cbufs; i++) { - (void)lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL); + assert(task->state); + if (!task->state) { + return; } lp_rast_shade_tile(task, arg); @@ -440,16 +385,20 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task, unsigned x, unsigned y, unsigned mask) { - const struct lp_rast_state *state = inputs->state; + const struct lp_rast_state *state = task->state; struct lp_fragment_shader_variant *variant = state->variant; - struct lp_rasterizer *rast = task->rast; + const struct lp_scene *scene = task->scene; uint8_t *color[PIPE_MAX_COLOR_BUFS]; - void *depth; + unsigned stride[PIPE_MAX_COLOR_BUFS]; + uint8_t *depth = NULL; + unsigned depth_stride = 0; unsigned i; assert(state); /* Sanity checks */ + assert(x < scene->tiles_x * TILE_SIZE); + assert(y < scene->tiles_y * TILE_SIZE); assert(x % TILE_VECTOR_WIDTH == 0); assert(y % TILE_VECTOR_HEIGHT == 0); @@ -457,83 +406,122 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task, assert((y % 4) == 0); /* color buffer */ - for (i = 0; i < rast->state.nr_cbufs; i++) { - color[i] = lp_rast_get_color_block_pointer(task, i, x, y); - assert(lp_check_alignment(color[i], 16)); + for (i = 0; i < scene->fb.nr_cbufs; i++) { + if (scene->fb.cbufs[i]) { + stride[i] = scene->cbufs[i].stride; + color[i] = lp_rast_get_color_block_pointer(task, i, x, y, + inputs->layer); + } + else { + stride[i] = 0; + color[i] = NULL; + } } /* depth buffer */ - depth = lp_rast_get_depth_block_pointer(task, x, y); - - - assert(lp_check_alignment(state->jit_context.blend_color, 16)); - - /* run shader on 4x4 block */ - BEGIN_JIT_CALL(state); - variant->jit_function[RAST_EDGE_TEST](&state->jit_context, - x, y, - inputs->facing, - inputs->a0, - inputs->dadx, - inputs->dady, - color, - depth, - mask, - &task->vis_counter); - END_JIT_CALL(); + if (scene->zsbuf.map) { + depth_stride = scene->zsbuf.stride; + depth = lp_rast_get_depth_block_pointer(task, x, y, inputs->layer); + } + + assert(lp_check_alignment(state->jit_context.u8_blend_color, 16)); + + /* + * The rasterizer may produce fragments outside our + * allocated 4x4 blocks hence need to filter them out here. + */ + if ((x % TILE_SIZE) < task->width && (y % TILE_SIZE) < task->height) { + /* not very accurate would need a popcount on the mask */ + /* always count this not worth bothering? */ + task->ps_invocations += 1 * variant->ps_inv_multiplier; + + /* Propagate non-interpolated raster state. */ + task->thread_data.raster_state.viewport_index = inputs->viewport_index; + + /* run shader on 4x4 block */ + BEGIN_JIT_CALL(state, task); + variant->jit_function[RAST_EDGE_TEST](&state->jit_context, + x, y, + inputs->frontfacing, + GET_A0(inputs), + GET_DADX(inputs), + GET_DADY(inputs), + color, + depth, + mask, + &task->thread_data, + stride, + depth_stride); + END_JIT_CALL(); + } } /** - * Set top row and left column of the tile's pixels to white. For debugging. + * Begin a new occlusion query. + * This is a bin command put in all bins. + * Called per thread. */ static void -outline_tile(uint8_t *tile) +lp_rast_begin_query(struct lp_rasterizer_task *task, + const union lp_rast_cmd_arg arg) { - const uint8_t val = 0xff; - unsigned i; - - for (i = 0; i < TILE_SIZE; i++) { - TILE_PIXEL(tile, i, 0, 0) = val; - TILE_PIXEL(tile, i, 0, 1) = val; - TILE_PIXEL(tile, i, 0, 2) = val; - TILE_PIXEL(tile, i, 0, 3) = val; + struct llvmpipe_query *pq = arg.query_obj; - TILE_PIXEL(tile, 0, i, 0) = val; - TILE_PIXEL(tile, 0, i, 1) = val; - TILE_PIXEL(tile, 0, i, 2) = val; - TILE_PIXEL(tile, 0, i, 3) = val; + switch (pq->type) { + case PIPE_QUERY_OCCLUSION_COUNTER: + case PIPE_QUERY_OCCLUSION_PREDICATE: + pq->start[task->thread_index] = task->thread_data.vis_counter; + break; + case PIPE_QUERY_PIPELINE_STATISTICS: + pq->start[task->thread_index] = task->ps_invocations; + break; + default: + assert(0); + break; } } /** - * Draw grid of gray lines at 16-pixel intervals across the tile to - * show the sub-tile boundaries. For debugging. + * End the current occlusion query. + * This is a bin command put in all bins. + * Called per thread. */ static void -outline_subtiles(uint8_t *tile) +lp_rast_end_query(struct lp_rasterizer_task *task, + const union lp_rast_cmd_arg arg) { - const uint8_t val = 0x80; - const unsigned step = 16; - unsigned i, j; + struct llvmpipe_query *pq = arg.query_obj; - for (i = 0; i < TILE_SIZE; i += step) { - for (j = 0; j < TILE_SIZE; j++) { - TILE_PIXEL(tile, i, j, 0) = val; - TILE_PIXEL(tile, i, j, 1) = val; - TILE_PIXEL(tile, i, j, 2) = val; - TILE_PIXEL(tile, i, j, 3) = val; - - TILE_PIXEL(tile, j, i, 0) = val; - TILE_PIXEL(tile, j, i, 1) = val; - TILE_PIXEL(tile, j, i, 2) = val; - TILE_PIXEL(tile, j, i, 3) = val; - } + switch (pq->type) { + case PIPE_QUERY_OCCLUSION_COUNTER: + case PIPE_QUERY_OCCLUSION_PREDICATE: + pq->end[task->thread_index] += + task->thread_data.vis_counter - pq->start[task->thread_index]; + pq->start[task->thread_index] = 0; + break; + case PIPE_QUERY_TIMESTAMP: + pq->end[task->thread_index] = os_time_get_nano(); + break; + case PIPE_QUERY_PIPELINE_STATISTICS: + pq->end[task->thread_index] += + task->ps_invocations - pq->start[task->thread_index]; + pq->start[task->thread_index] = 0; + break; + default: + assert(0); + break; } +} + - outline_tile(tile); +void +lp_rast_set_state(struct lp_rasterizer_task *task, + const union lp_rast_cmd_arg arg) +{ + task->state = arg.state; } @@ -544,98 +532,69 @@ outline_subtiles(uint8_t *tile) static void lp_rast_tile_end(struct lp_rasterizer_task *task) { -#ifdef DEBUG - if (LP_DEBUG & (DEBUG_SHOW_SUBTILES | DEBUG_SHOW_TILES)) { - struct lp_rasterizer *rast = task->rast; - unsigned buf; - - for (buf = 0; buf < rast->state.nr_cbufs; buf++) { - uint8_t *color = lp_rast_get_color_block_pointer(task, buf, - task->x, task->y); - - if (LP_DEBUG & DEBUG_SHOW_SUBTILES) - outline_subtiles(color); - else if (LP_DEBUG & DEBUG_SHOW_TILES) - outline_tile(color); - } - } -#else - (void) outline_subtiles; -#endif - - { - union lp_rast_cmd_arg dummy = {0}; - lp_rast_store_linear_color(task, dummy); - } + unsigned i; - if (task->query) { - union lp_rast_cmd_arg dummy = {0}; - lp_rast_end_query(task, dummy); + for (i = 0; i < task->scene->num_active_queries; ++i) { + lp_rast_end_query(task, lp_rast_arg_query(task->scene->active_queries[i])); } /* debug */ memset(task->color_tiles, 0, sizeof(task->color_tiles)); task->depth_tile = NULL; -} - - -/** - * Signal on a fence. This is called during bin execution/rasterization. - * Called per thread. - */ -void -lp_rast_fence(struct lp_rasterizer_task *task, - const union lp_rast_cmd_arg arg) -{ - struct lp_fence *fence = arg.fence; - lp_fence_signal(fence); + task->bin = NULL; } - -/** - * Begin a new occlusion query. - * This is a bin command put in all bins. - * Called per thread. - */ -void -lp_rast_begin_query(struct lp_rasterizer_task *task, - const union lp_rast_cmd_arg arg) +static lp_rast_cmd_func dispatch[LP_RAST_OP_MAX] = { - struct llvmpipe_query *pq = arg.query_obj; - - assert(task->query == NULL); - task->vis_counter = 0; - task->query = pq; - pq->count[task->thread_index] = 0; -} + lp_rast_clear_color, + lp_rast_clear_zstencil, + lp_rast_triangle_1, + lp_rast_triangle_2, + lp_rast_triangle_3, + lp_rast_triangle_4, + lp_rast_triangle_5, + lp_rast_triangle_6, + lp_rast_triangle_7, + lp_rast_triangle_8, + lp_rast_triangle_3_4, + lp_rast_triangle_3_16, + lp_rast_triangle_4_16, + lp_rast_shade_tile, + lp_rast_shade_tile_opaque, + lp_rast_begin_query, + lp_rast_end_query, + lp_rast_set_state, + lp_rast_triangle_32_1, + lp_rast_triangle_32_2, + lp_rast_triangle_32_3, + lp_rast_triangle_32_4, + lp_rast_triangle_32_5, + lp_rast_triangle_32_6, + lp_rast_triangle_32_7, + lp_rast_triangle_32_8, + lp_rast_triangle_32_3_4, + lp_rast_triangle_32_3_16, + lp_rast_triangle_32_4_16 +}; -/* Much like begin_query, but don't reset the counter to zero. - */ -void -lp_rast_restart_query(struct lp_rasterizer_task *task, - const union lp_rast_cmd_arg arg) +static void +do_rasterize_bin(struct lp_rasterizer_task *task, + const struct cmd_bin *bin, + int x, int y) { - struct llvmpipe_query *pq = arg.query_obj; + const struct cmd_block *block; + unsigned k; - assert(task->query == NULL); - task->vis_counter = 0; - task->query = pq; -} - + if (0) + lp_debug_bin(bin, x, y); -/** - * End the current occlusion query. - * This is a bin command put in all bins. - * Called per thread. - */ -void -lp_rast_end_query(struct lp_rasterizer_task *task, - const union lp_rast_cmd_arg arg) -{ - task->query->count[task->thread_index] += task->vis_counter; - task->query = NULL; + for (block = bin->head; block; block = block->next) { + for (k = 0; k < block->count; k++) { + dispatch[block->cmd[k]]( task, block->arg[k] ); + } + } } @@ -648,75 +607,26 @@ lp_rast_end_query(struct lp_rasterizer_task *task, */ static void rasterize_bin(struct lp_rasterizer_task *task, - const struct cmd_bin *bin, - int x, int y) + const struct cmd_bin *bin, int x, int y ) { - const struct cmd_block_list *commands = &bin->commands; - struct cmd_block *block; - unsigned k; - - lp_rast_tile_begin( task, x * TILE_SIZE, y * TILE_SIZE ); + lp_rast_tile_begin( task, bin, x, y ); - /* simply execute each of the commands in the block list */ - for (block = commands->head; block; block = block->next) { - for (k = 0; k < block->count; k++) { - block->cmd[k]( task, block->arg[k] ); - } - } + do_rasterize_bin(task, bin, x, y); lp_rast_tile_end(task); - /* Free data for this bin. - */ - lp_scene_bin_reset( task->rast->curr_scene, x, y); -} - - -#define RAST(x) { lp_rast_##x, #x } -static struct { - lp_rast_cmd cmd; - const char *name; -} cmd_names[] = -{ - RAST(clear_color), - RAST(clear_zstencil), - RAST(triangle_1), - RAST(triangle_2), - RAST(triangle_3), - RAST(triangle_4), - RAST(triangle_5), - RAST(triangle_6), - RAST(triangle_7), - RAST(shade_tile), - RAST(shade_tile_opaque), - RAST(store_linear_color), - RAST(fence), - RAST(begin_query), - RAST(restart_query), - RAST(end_query), -}; - -static void -debug_bin( const struct cmd_bin *bin ) -{ - const struct cmd_block *head = bin->commands.head; - int i, j; - - for (i = 0; i < head->count; i++) { - debug_printf("%d: ", i); - for (j = 0; j < Elements(cmd_names); j++) { - if (head->cmd[i] == cmd_names[j].cmd) { - debug_printf("%s\n", cmd_names[j].name); - break; - } - } - if (j == Elements(cmd_names)) - debug_printf("...other\n"); + /* Debug/Perf flags: + */ + if (bin->head->count == 1) { + if (bin->head->cmd[0] == LP_RAST_OP_SHADE_TILE_OPAQUE) + LP_COUNT(nr_pure_shade_opaque_64); + else if (bin->head->cmd[0] == LP_RAST_OP_SHADE_TILE) + LP_COUNT(nr_pure_shade_64); } - } + /* An empty bin is one that just loads the contents of the tile and * stores them again unchanged. This typically happens when bins have * been flushed for some reason in the middle of a frame, or when @@ -727,12 +637,10 @@ debug_bin( const struct cmd_bin *bin ) static boolean is_empty_bin( const struct cmd_bin *bin ) { - if (0) debug_bin(bin); - return bin->commands.head->count == 0; + return bin->head == NULL; } - /** * Rasterize/execute all bins within a scene. * Called per thread. @@ -741,33 +649,28 @@ static void rasterize_scene(struct lp_rasterizer_task *task, struct lp_scene *scene) { - /* loop over scene bins, rasterize each */ -#if 0 - { - unsigned i, j; - for (i = 0; i < scene->tiles_x; i++) { - for (j = 0; j < scene->tiles_y; j++) { - struct cmd_bin *bin = lp_scene_get_bin(scene, i, j); - rasterize_bin(task, bin, i, j); + task->scene = scene; + + if (!task->rast->no_rast && !scene->discard) { + /* loop over scene bins, rasterize each */ + { + struct cmd_bin *bin; + int i, j; + + assert(scene); + while ((bin = lp_scene_bin_iter_next(scene, &i, &j))) { + if (!is_empty_bin( bin )) + rasterize_bin(task, bin, i, j); } } } -#else - { - struct cmd_bin *bin; - int x, y; - - assert(scene); - while ((bin = lp_scene_bin_iter_next(scene, &x, &y))) { - if (!is_empty_bin( bin )) - rasterize_bin(task, bin, x, y); - } - } -#endif + if (scene->fence) { - lp_rast_fence(task, lp_rast_arg_fence(scene->fence)); + lp_fence_signal(scene->fence); } + + task->scene = NULL; } @@ -782,15 +685,21 @@ lp_rast_queue_scene( struct lp_rasterizer *rast, if (rast->num_threads == 0) { /* no threading */ + unsigned fpstate = util_fpstate_get(); + + /* Make sure that denorms are treated like zeros. This is + * the behavior required by D3D10. OpenGL doesn't care. + */ + util_fpstate_set_denorms_to_zero(fpstate); lp_rast_begin( rast, scene ); rasterize_scene( &rast->tasks[0], scene ); - lp_scene_reset( scene ); - lp_rast_end( rast ); + util_fpstate_set(fpstate); + rast->curr_scene = NULL; } else { @@ -833,11 +742,17 @@ lp_rast_finish( struct lp_rasterizer *rast ) * 2. do work * 3. signal that we're done */ -static PIPE_THREAD_ROUTINE( thread_func, init_data ) +static PIPE_THREAD_ROUTINE( thread_function, init_data ) { struct lp_rasterizer_task *task = (struct lp_rasterizer_task *) init_data; struct lp_rasterizer *rast = task->rast; boolean debug = false; + unsigned fpstate = util_fpstate_get(); + + /* Make sure that denorms are treated like zeros. This is + * the behavior required by D3D10. OpenGL doesn't care. + */ + util_fpstate_set_denorms_to_zero(fpstate); while (1) { /* wait for work */ @@ -885,7 +800,11 @@ static PIPE_THREAD_ROUTINE( thread_func, init_data ) pipe_semaphore_signal(&task->work_done); } - return NULL; +#ifdef _WIN32 + pipe_semaphore_signal(&task->work_done); +#endif + + return 0; } @@ -901,7 +820,7 @@ create_rast_threads(struct lp_rasterizer *rast) for (i = 0; i < rast->num_threads; i++) { pipe_semaphore_init(&rast->tasks[i].work_ready, 0); pipe_semaphore_init(&rast->tasks[i].work_done, 0); - rast->threads[i] = pipe_thread_create(thread_func, + rast->threads[i] = pipe_thread_create(thread_function, (void *) &rast->tasks[i]); } } @@ -920,10 +839,14 @@ lp_rast_create( unsigned num_threads ) unsigned i; rast = CALLOC_STRUCT(lp_rasterizer); - if(!rast) - return NULL; + if (!rast) { + goto no_rast; + } rast->full_scenes = lp_scene_queue_create(); + if (!rast->full_scenes) { + goto no_full_scenes; + } for (i = 0; i < Elements(rast->tasks); i++) { struct lp_rasterizer_task *task = &rast->tasks[i]; @@ -933,16 +856,21 @@ lp_rast_create( unsigned num_threads ) rast->num_threads = num_threads; + rast->no_rast = debug_get_bool_option("LP_NO_RAST", FALSE); + create_rast_threads(rast); /* for synchronizing rasterization threads */ pipe_barrier_init( &rast->barrier, rast->num_threads ); - memset(lp_swizzled_cbuf, 0, sizeof lp_swizzled_cbuf); - memset(lp_dummy_tile, 0, sizeof lp_dummy_tile); return rast; + +no_full_scenes: + FREE(rast); +no_rast: + return NULL; } @@ -961,9 +889,15 @@ void lp_rast_destroy( struct lp_rasterizer *rast ) pipe_semaphore_signal(&rast->tasks[i].work_ready); } - /* Wait for threads to terminate before cleaning up per-thread data */ + /* Wait for threads to terminate before cleaning up per-thread data. + * We don't actually call pipe_thread_wait to avoid dead lock on Windows + * per https://bugs.freedesktop.org/show_bug.cgi?id=76252 */ for (i = 0; i < rast->num_threads; i++) { +#ifdef _WIN32 + pipe_semaphore_wait(&rast->tasks[i].work_done); +#else pipe_thread_wait(rast->threads[i]); +#endif } /* Clean up per-thread data */ @@ -981,11 +915,3 @@ void lp_rast_destroy( struct lp_rasterizer *rast ) } -/** Return number of rasterization threads */ -unsigned -lp_rast_get_num_threads( struct lp_rasterizer *rast ) -{ - return rast->num_threads; -} - -