X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fllvmpipe%2Flp_rast.c;h=939944aa791359e36fb0b5ff0e3d1de6d98f81a0;hb=01ab218bbc5c8058a99077a6bc3dc9884e9d218a;hp=1a82dd5694e36b399164b2185f753e97642e45a6;hpb=2b3e1ad731d2bd095a680d3120619972a7eb0242;p=mesa.git diff --git a/src/gallium/drivers/llvmpipe/lp_rast.c b/src/gallium/drivers/llvmpipe/lp_rast.c index 1a82dd5694e..939944aa791 100644 --- a/src/gallium/drivers/llvmpipe/lp_rast.c +++ b/src/gallium/drivers/llvmpipe/lp_rast.c @@ -28,18 +28,33 @@ #include #include "util/u_memory.h" #include "util/u_math.h" +#include "util/u_rect.h" #include "util/u_surface.h" +#include "util/u_pack_color.h" +#include "util/u_string.h" +#include "util/u_thread.h" + +#include "util/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_format.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 /** @@ -50,39 +65,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_NONE); - } - - 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 ); } @@ -90,166 +77,95 @@ 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 } /** - * Begining rasterization of a tile. + * Beginning rasterization of a tile. * \param x window X position of the tile, in pixels * \param y window Y position of the tile, in pixels */ 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; - unsigned buf; + unsigned i; + struct lp_scene *scene = task->scene; LP_DBG(DEBUG_RAST, "%s %d,%d\n", __FUNCTION__, x, y); - assert(x % TILE_SIZE == 0); - assert(y % TILE_SIZE == 0); - - task->x = x; - task->y = y; - - if (scene->has_color_clear) - usage = LP_TEX_USAGE_WRITE_ALL; - else - usage = LP_TEX_USAGE_READ_WRITE; - - /* get pointers to color tile(s) */ - for (buf = 0; buf < rast->state.nr_cbufs; buf++) { - struct pipe_surface *cbuf = rast->curr_scene->fb.cbufs[buf]; - struct llvmpipe_resource *lpt; - assert(cbuf); - lpt = llvmpipe_resource(cbuf->texture); - task->color_tiles[buf] = llvmpipe_get_texture_tile(lpt, - cbuf->face + cbuf->zslice, - cbuf->level, - usage, - x, y); - assert(task->color_tiles[buf]); - } - - /* 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->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->thread_data.vis_counter = 0; + task->ps_invocations = 0; + + for (i = 0; i < task->scene->fb.nr_cbufs; i++) { + if (task->scene->fb.cbufs[i]) { + task->color_tiles[i] = scene->cbufs[i].map + + scene->cbufs[i].stride * task->y + + scene->cbufs[i].format_bytes * task->x; } } + if (task->scene->fb.zsbuf) { + task->depth_tile = scene->zsbuf.map + + scene->zsbuf.stride * task->y + + scene->zsbuf.format_bytes * task->x; + } } /** * 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 = task->color_tiles[i]; - 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 = task->color_tiles[i]; - 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); } @@ -257,232 +173,247 @@ 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; + if (scene->fb.zsbuf) { + unsigned layer; + uint8_t *dst_layer = task->depth_tile; + block_size = util_format_get_blocksize(scene->fb.zsbuf->format); - if (lp_is_dummy_tile(dst)) - return; + clear_value &= clear_mask; - assert(dst == lp_rast_get_depth_block_pointer(task, task->x, task->y)); + for (layer = 0; layer <= scene->fb_max_layer; layer++) { + dst = dst_layer; - 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; + 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; + } } - 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; + + default: + assert(0); + break; } + dst_layer += scene->zsbuf.layer_stride; } - break; - default: - assert(0); - break; } } -/** - * Load tile color from the framebuffer surface. - * This is a bin command called during bin processing. - */ -#if 0 -void -lp_rast_load_color(struct lp_rasterizer_task *task, - const union lp_rast_cmd_arg arg) -{ - struct lp_rasterizer *rast = task->rast; - unsigned buf; - enum lp_texture_usage usage; - - LP_DBG(DEBUG_RAST, "%s at %u, %u\n", __FUNCTION__, x, y); - - if (scene->has_color_clear) - usage = LP_TEX_USAGE_WRITE_ALL; - else - usage = LP_TEX_USAGE_READ_WRITE; - - /* Get pointers to color tile(s). - * This will convert linear data to tiled if needed. - */ - for (buf = 0; buf < rast->state.nr_cbufs; buf++) { - struct pipe_surface *cbuf = rast->curr_scene->fb.cbufs[buf]; - struct llvmpipe_texture *lpt; - assert(cbuf); - lpt = llvmpipe_texture(cbuf->texture); - task->color_tiles[buf] = llvmpipe_get_texture_tile(lpt, - cbuf->face + cbuf->zslice, - cbuf->level, - usage, - task->x, task->y); - assert(task->color_tiles[buf]); - } -} -#endif - - -/** - * 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_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 = cbuf->face, level = cbuf->level; - struct llvmpipe_resource *lpt = llvmpipe_resource(cbuf->texture); - /* this will convert the tiled data to linear if needed */ - (void) llvmpipe_get_texture_tile_linear(lpt, face, level, - LP_TEX_USAGE_READ, - task->x, task->y); - } -} - - -/** - * This is a bin command called during bin processing. - */ -void -lp_rast_set_state(struct lp_rasterizer_task *task, - const union lp_rast_cmd_arg arg) -{ - const struct lp_rast_state *state = arg.set_state; - - LP_DBG(DEBUG_RAST, "%s %p\n", __FUNCTION__, (void *) state); - - /* just set the current state pointer for this rasterizer */ - task->current_state = state; -} - /** * Run the shader on all blocks in a tile. This is used when a tile is * 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_rast_state *state = task->current_state; + const struct lp_scene *scene = task->scene; const struct lp_rast_shader_inputs *inputs = arg.shade_tile; - 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, task); variant->jit_function[RAST_WHOLE]( &state->jit_context, - tile_x + x, tile_y + y, - inputs->facing, - inputs->a0, - inputs->dadx, - inputs->dady, - color, - depth, - INT_MIN, INT_MIN, INT_MIN, - NULL, NULL, NULL, &task->vis_counter); + tile_x + x, tile_y + y, + inputs->frontfacing, + GET_A0(inputs), + GET_DADX(inputs), + GET_DADY(inputs), + color, + depth, + 0xffff, + &task->thread_data, + stride, + depth_stride); + END_JIT_CALL(); } } } /** - * Compute shading for a 4x4 block of pixels. + * Run the shader on all blocks in a tile. This is used when a tile is + * completely contained inside a triangle, and the shader is opaque. + * This is a bin command called during bin processing. + */ +static void +lp_rast_shade_tile_opaque(struct lp_rasterizer_task *task, + const union lp_rast_cmd_arg arg) +{ + LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__); + + assert(task->state); + if (!task->state) { + return; + } + + lp_rast_shade_tile(task, arg); +} + + +/** + * Compute shading for a 4x4 block of pixels inside a triangle. * This is a bin command called during bin processing. * \param x X position of quad in window coords * \param y Y position of quad in window coords */ -void lp_rast_shade_quads( struct lp_rasterizer_task *task, - const struct lp_rast_shader_inputs *inputs, - unsigned x, unsigned y, - int32_t c1, int32_t c2, int32_t c3) +void +lp_rast_shade_quads_mask(struct lp_rasterizer_task *task, + const struct lp_rast_shader_inputs *inputs, + unsigned x, unsigned y, + unsigned mask) { - const struct lp_rast_state *state = task->current_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); @@ -490,87 +421,124 @@ void lp_rast_shade_quads( 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)); - - assert(lp_check_alignment(inputs->step[0], 16)); - assert(lp_check_alignment(inputs->step[1], 16)); - assert(lp_check_alignment(inputs->step[2], 16)); - - /* run shader on 4x4 block */ - variant->jit_function[RAST_EDGE_TEST]( &state->jit_context, - x, y, - inputs->facing, - inputs->a0, - inputs->dadx, - inputs->dady, - color, - depth, - c1, c2, c3, - inputs->step[0], - inputs->step[1], - inputs->step[2], - &task->vis_counter); + 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: + case PIPE_QUERY_OCCLUSION_PREDICATE_CONSERVATIVE: + 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: + case PIPE_QUERY_OCCLUSION_PREDICATE_CONSERVATIVE: + 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; } @@ -581,97 +549,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); - } + unsigned i; + + for (i = 0; i < task->scene->num_active_queries; ++i) { + lp_rast_end_query(task, lp_rast_arg_query(task->scene->active_queries[i])); } -#else - (void) outline_subtiles; -#endif /* 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] = { - /* Reset the per-task counter */ - task->vis_counter = 0; -} - - -/** - * 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) -{ - struct llvmpipe_query *pq = arg.query_obj; - - pipe_mutex_lock(pq->mutex); - { - /* Accumulate the visible fragment counter from this tile in - * the query object. - */ - pq->count[task->thread_index] += task->vis_counter; + 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 +}; - /* check if this is the last tile in the scene */ - pq->tile_count++; - if (pq->tile_count == pq->num_tiles) { - uint i; - /* sum the per-thread counters for the query */ - pq->result = 0; - for (i = 0; i < LP_MAX_THREADS; i++) { - pq->result += pq->count[i]; - } +static void +do_rasterize_bin(struct lp_rasterizer_task *task, + const struct cmd_bin *bin, + int x, int y) +{ + const struct cmd_block *block; + unsigned k; - /* reset counters (in case this query is re-used in the scene) */ - memset(pq->count, 0, sizeof(pq->count)); + if (0) + lp_debug_bin(bin, x, y); - pq->tile_count = 0; - pq->binned = FALSE; - pq->done = TRUE; + for (block = bin->head; block; block = block->next) { + for (k = 0; k < block->count; k++) { + dispatch[block->cmd[k]]( task, block->arg[k] ); } } - pipe_mutex_unlock(pq->mutex); } @@ -684,68 +624,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, bin, x, y ); - lp_rast_tile_begin( task, x * TILE_SIZE, y * TILE_SIZE ); - - /* 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), - RAST(shade_tile), - RAST(set_state), - RAST(store_color), - RAST(fence), - RAST(begin_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 @@ -756,34 +654,10 @@ debug_bin( const struct cmd_bin *bin ) static boolean is_empty_bin( const struct cmd_bin *bin ) { - const struct cmd_block *head = bin->commands.head; - int i; - - if (0) - debug_bin(bin); - - /* We emit at most two load-tile commands at the start of the first - * command block. In addition we seem to emit a couple of - * set-state commands even in empty bins. - * - * As a heuristic, if a bin has more than 4 commands, consider it - * non-empty. - */ - if (head->next != NULL || - head->count > 4) { - return FALSE; - } - - for (i = 0; i < head->count; i++) - if (head->cmd[i] != lp_rast_set_state) { - return FALSE; - } - - return TRUE; + return bin->head == NULL; } - /** * Rasterize/execute all bins within a scene. * Called per thread. @@ -792,29 +666,53 @@ 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; + + /* Clear the cache tags. This should not always be necessary but + simpler for now. */ +#if LP_USE_TEXTURE_CACHE + memset(task->thread_data.cache->cache_tags, 0, + sizeof(task->thread_data.cache->cache_tags)); +#if LP_BUILD_FORMAT_CACHE_DEBUG + task->thread_data.cache->cache_access_total = 0; + task->thread_data.cache->cache_access_miss = 0; +#endif +#endif + + 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); + +#if LP_BUILD_FORMAT_CACHE_DEBUG + { + uint64_t total, miss; + total = task->thread_data.cache->cache_access_total; + miss = task->thread_data.cache->cache_access_miss; + if (total) { + debug_printf("thread %d cache access %llu miss %llu hit rate %f\n", + task->thread_index, (long long unsigned)total, + (long long unsigned)miss, + (float)(total - miss)/(float)total); } } #endif + + if (scene->fence) { + lp_fence_signal(scene->fence); + } + + task->scene = NULL; } @@ -829,15 +727,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 { @@ -880,11 +784,23 @@ 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 int +thread_function(void *init_data) { struct lp_rasterizer_task *task = (struct lp_rasterizer_task *) init_data; struct lp_rasterizer *rast = task->rast; boolean debug = false; + char thread_name[16]; + unsigned fpstate; + + util_snprintf(thread_name, sizeof thread_name, "llvmpipe-%u", task->thread_index); + u_thread_setname(thread_name); + + /* Make sure that denorms are treated like zeros. This is + * the behavior required by D3D10. OpenGL doesn't care. + */ + fpstate = util_fpstate_get(); + util_fpstate_set_denorms_to_zero(fpstate); while (1) { /* wait for work */ @@ -907,7 +823,7 @@ static PIPE_THREAD_ROUTINE( thread_func, init_data ) /* Wait for all threads to get here so that threads[1+] don't * get a null rast->curr_scene pointer. */ - pipe_barrier_wait( &rast->barrier ); + util_barrier_wait( &rast->barrier ); /* do work */ if (debug) @@ -917,7 +833,7 @@ static PIPE_THREAD_ROUTINE( thread_func, init_data ) rast->curr_scene); /* wait for all threads to finish with this scene */ - pipe_barrier_wait( &rast->barrier ); + util_barrier_wait( &rast->barrier ); /* XXX: shouldn't be necessary: */ @@ -932,7 +848,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; } @@ -948,7 +868,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] = u_thread_create(thread_function, (void *) &rast->tasks[i]); } } @@ -967,25 +887,53 @@ 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++) { + for (i = 0; i < MAX2(1, num_threads); i++) { struct lp_rasterizer_task *task = &rast->tasks[i]; task->rast = rast; task->thread_index = i; + task->thread_data.cache = align_malloc(sizeof(struct lp_build_format_cache), + 16); + if (!task->thread_data.cache) { + goto no_thread_data_cache; + } } 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 ); + if (rast->num_threads > 0) { + util_barrier_init( &rast->barrier, rast->num_threads ); + } + + memset(lp_dummy_tile, 0, sizeof lp_dummy_tile); return rast; + +no_thread_data_cache: + for (i = 0; i < MAX2(1, rast->num_threads); i++) { + if (rast->tasks[i].thread_data.cache) { + align_free(rast->tasks[i].thread_data.cache); + } + } + + lp_scene_queue_destroy(rast->full_scenes); +no_full_scenes: + FREE(rast); +no_rast: + return NULL; } @@ -1004,9 +952,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++) { - pipe_thread_wait(rast->threads[i]); +#ifdef _WIN32 + pipe_semaphore_wait(&rast->tasks[i].work_done); +#else + thrd_join(rast->threads[i], NULL); +#endif } /* Clean up per-thread data */ @@ -1014,9 +968,14 @@ void lp_rast_destroy( struct lp_rasterizer *rast ) pipe_semaphore_destroy(&rast->tasks[i].work_ready); pipe_semaphore_destroy(&rast->tasks[i].work_done); } + for (i = 0; i < MAX2(1, rast->num_threads); i++) { + align_free(rast->tasks[i].thread_data.cache); + } /* for synchronizing rasterization threads */ - pipe_barrier_destroy( &rast->barrier ); + if (rast->num_threads > 0) { + util_barrier_destroy( &rast->barrier ); + } lp_scene_queue_destroy(rast->full_scenes); @@ -1024,11 +983,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; -} - -