X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fllvmpipe%2Flp_rast.c;h=777c4450c7f0cea78e0066b46e60728cf5a3d056;hb=59fa26902d56e068de1769a62d8329e6777bba92;hp=44e8324b2b148c783ffe6fba546852c135cc14d5;hpb=ab2f573634d21cf5d2c0843960b98e890d495793;p=mesa.git diff --git a/src/gallium/drivers/llvmpipe/lp_rast.c b/src/gallium/drivers/llvmpipe/lp_rast.c index 44e8324b2b1..777c4450c7f 100644 --- a/src/gallium/drivers/llvmpipe/lp_rast.c +++ b/src/gallium/drivers/llvmpipe/lp_rast.c @@ -31,16 +31,20 @@ #include "util/u_rect.h" #include "util/u_surface.h" #include "util/u_pack_color.h" - -#include "os/os_time.h" +#include "util/u_string.h" +#include "util/u_thread.h" +#include "util/u_memset.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 "gallivm/lp_bld_format.h" #include "gallivm/lp_bld_debug.h" #include "lp_scene.h" #include "lp_tex_sample.h" @@ -52,6 +56,10 @@ const struct lp_rast_state *jit_state = NULL; const struct lp_rasterizer_task *jit_task = NULL; #endif +const float lp_sample_pos_4x[4][2] = { { 0.375, 0.125 }, + { 0.875, 0.375 }, + { 0.125, 0.625 }, + { 0.625, 0.875 } }; /** * Begin rasterizing a scene. @@ -61,7 +69,6 @@ static void lp_rast_begin( struct lp_rasterizer *rast, struct lp_scene *scene ) { - rast->curr_scene = scene; LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__); @@ -81,191 +88,210 @@ lp_rast_end( struct lp_rasterizer *rast ) /** - * 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, - const struct cmd_bin *bin) + const struct cmd_bin *bin, + int x, int y) { - const struct lp_scene *scene = task->scene; - enum lp_texture_usage usage; + unsigned i; + struct lp_scene *scene = task->scene; - LP_DBG(DEBUG_RAST, "%s %d,%d\n", __FUNCTION__, bin->x, bin->y); + LP_DBG(DEBUG_RAST, "%s %d,%d\n", __FUNCTION__, x, y); task->bin = bin; - task->x = bin->x * TILE_SIZE; - task->y = bin->y * TILE_SIZE; - - /* reset pointers to color tile(s) */ - memset(task->color_tiles, 0, sizeof(task->color_tiles)); - - /* get pointer to depth/stencil tile */ - { - struct pipe_surface *zsbuf = task->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->u.tex.first_layer, - zsbuf->u.tex.level, - usage, - task->x, - task->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, - task->x, - task->y); - - assert(task->depth_tile); - } - else { - task->depth_tile = NULL; + 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->thread_data.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. */ static void lp_rast_clear_color(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { const struct lp_scene *scene = task->scene; - uint8_t clear_color[4]; + unsigned cbuf = arg.clear_rb->cbuf; + union util_color uc; + enum pipe_format format; - unsigned i; - - for (i = 0; i < 4; ++i) { - clear_color[i] = float_to_ubyte(arg.clear_color[i]); - } - - 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]); + /* we never bin clear commands for non-existing buffers */ + assert(cbuf < scene->fb.nr_cbufs); + assert(scene->fb.cbufs[cbuf]); - for (i = 0; i < scene->fb.nr_cbufs; i++) { - const struct lp_scene *scene = task->scene; - union util_color uc; - - util_pack_color(arg.clear_color, - scene->fb.cbufs[i]->format, &uc); + format = scene->fb.cbufs[cbuf]->format; + uc = arg.clear_rb->color_val; - util_fill_rect(scene->cbufs[i].map, - scene->fb.cbufs[i]->format, - scene->cbufs[i].stride, - task->x, - task->y, - TILE_SIZE, - TILE_SIZE, - &uc); + /* + * 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]); + + for (unsigned s = 0; s < scene->cbufs[cbuf].nr_samples; s++) { + void *map = (char *)scene->cbufs[cbuf].map + scene->cbufs[cbuf].sample_stride * s; + util_fill_box(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); } - - - - /** * Clear the rasterizer's current z/stencil tile. * This is a bin command called during bin processing. + * Clear commands always clear all bound layers. */ static void lp_rast_clear_zstencil(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { const struct lp_scene *scene = task->scene; - uint32_t clear_value = arg.clear_zstencil.value; - uint32_t clear_mask = arg.clear_zstencil.mask; - const unsigned height = TILE_SIZE / TILE_VECTOR_HEIGHT; - const unsigned width = TILE_SIZE * TILE_VECTOR_HEIGHT; - const unsigned block_size = scene->zsbuf.blocksize; - const unsigned dst_stride = scene->zsbuf.stride * TILE_VECTOR_HEIGHT; + 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: value=0x%08x, mask=0x%08x\n", __FUNCTION__, clear_value, clear_mask); /* - * Clear the area 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; - - clear_value &= clear_mask; - - 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; + if (scene->fb.zsbuf) { + unsigned layer; + + for (unsigned s = 0; s < scene->zsbuf.nr_samples; s++) { + uint8_t *dst_layer = task->depth_tile + (s * scene->zsbuf.sample_stride); + 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); + for (i = 0; i < height; i++) { + uint8_t *row = (uint8_t *)dst; + memset(row, (uint8_t) clear_value, width); + dst += dst_stride; + } + 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++) { + util_memset32(dst, clear_value, width); + 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 += dst_stride; + dst_layer += scene->zsbuf.layer_stride; } } - break; - default: - assert(0); - break; } } @@ -302,22 +328,45 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task, 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]; unsigned stride[PIPE_MAX_COLOR_BUFS]; - uint32_t *depth; + unsigned sample_stride[PIPE_MAX_COLOR_BUFS]; + uint8_t *depth = NULL; + unsigned depth_stride = 0; + unsigned depth_sample_stride = 0; unsigned i; /* color buffer */ for (i = 0; i < scene->fb.nr_cbufs; i++){ - stride[i] = scene->cbufs[i].stride; - - color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, tile_x + x, tile_y + y); + if (scene->fb.cbufs[i]) { + stride[i] = scene->cbufs[i].stride; + sample_stride[i] = scene->cbufs[i].sample_stride; + color[i] = lp_rast_get_color_block_pointer(task, i, tile_x + x, + tile_y + y, inputs->layer); + } + else { + stride[i] = 0; + sample_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; + depth_sample_stride = scene->zsbuf.sample_stride; + } + + uint64_t mask = 0; + for (unsigned i = 0; i < scene->fb_max_samples; i++) + mask |= (uint64_t)(0xffff) << (16 * i); + + /* 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); @@ -329,9 +378,12 @@ lp_rast_shade_tile(struct lp_rasterizer_task *task, GET_DADY(inputs), color, depth, - 0xffff, - &task->vis_counter, - stride); + mask, + &task->thread_data, + stride, + depth_stride, + sample_stride, + depth_sample_stride); END_JIT_CALL(); } } @@ -365,17 +417,20 @@ lp_rast_shade_tile_opaque(struct lp_rasterizer_task *task, * \param y Y position of quad in window coords */ void -lp_rast_shade_quads_mask(struct lp_rasterizer_task *task, - const struct lp_rast_shader_inputs *inputs, - unsigned x, unsigned y, - unsigned mask) +lp_rast_shade_quads_mask_sample(struct lp_rasterizer_task *task, + const struct lp_rast_shader_inputs *inputs, + unsigned x, unsigned y, + uint64_t mask) { const struct lp_rast_state *state = task->state; struct lp_fragment_shader_variant *variant = state->variant; const struct lp_scene *scene = task->scene; uint8_t *color[PIPE_MAX_COLOR_BUFS]; unsigned stride[PIPE_MAX_COLOR_BUFS]; - void *depth; + unsigned sample_stride[PIPE_MAX_COLOR_BUFS]; + uint8_t *depth = NULL; + unsigned depth_stride = 0; + unsigned depth_sample_stride = 0; unsigned i; assert(state); @@ -391,34 +446,67 @@ lp_rast_shade_quads_mask(struct lp_rasterizer_task *task, /* color buffer */ for (i = 0; i < scene->fb.nr_cbufs; i++) { - stride[i] = scene->cbufs[i].stride; - - color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y); + if (scene->fb.cbufs[i]) { + stride[i] = scene->cbufs[i].stride; + sample_stride[i] = scene->cbufs[i].sample_stride; + color[i] = lp_rast_get_color_block_pointer(task, i, x, y, + inputs->layer); + } + else { + stride[i] = 0; + sample_stride[i] = 0; + color[i] = NULL; + } } /* depth buffer */ - depth = lp_rast_get_depth_block_pointer(task, x, y); - + if (scene->zsbuf.map) { + depth_stride = scene->zsbuf.stride; + depth_sample_stride = scene->zsbuf.sample_stride; + depth = lp_rast_get_depth_block_pointer(task, x, y, inputs->layer); + } assert(lp_check_alignment(state->jit_context.u8_blend_color, 16)); - /* 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->vis_counter, - stride); - END_JIT_CALL(); + /* + * 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) { + /* 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, + sample_stride, + depth_sample_stride); + END_JIT_CALL(); + } } - +void +lp_rast_shade_quads_mask(struct lp_rasterizer_task *task, + const struct lp_rast_shader_inputs *inputs, + unsigned x, unsigned y, + unsigned mask) +{ + uint64_t new_mask = 0; + for (unsigned i = 0; i < task->scene->fb_max_samples; i++) + new_mask |= ((uint64_t)mask) << (16 * i); + lp_rast_shade_quads_mask_sample(task, inputs, x, y, new_mask); +} /** * Begin a new occlusion query. @@ -431,21 +519,19 @@ lp_rast_begin_query(struct lp_rasterizer_task *task, { struct llvmpipe_query *pq = arg.query_obj; - assert(task->query[pq->type] == NULL); - switch (pq->type) { case PIPE_QUERY_OCCLUSION_COUNTER: - task->vis_counter = 0; + 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_PRIMITIVES_GENERATED: - case PIPE_QUERY_PRIMITIVES_EMITTED: + case PIPE_QUERY_PIPELINE_STATISTICS: + pq->start[task->thread_index] = task->thread_data.ps_invocations; break; default: assert(0); break; } - - task->query[pq->type] = pq; } @@ -459,26 +545,27 @@ lp_rast_end_query(struct lp_rasterizer_task *task, const union lp_rast_cmd_arg arg) { struct llvmpipe_query *pq = arg.query_obj; - assert(task->query[pq->type] == pq || pq->type == PIPE_QUERY_TIMESTAMP); switch (pq->type) { case PIPE_QUERY_OCCLUSION_COUNTER: - pq->count[task->thread_index] += task->vis_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->count[task->thread_index] = os_time_get_nano(); + pq->end[task->thread_index] = os_time_get_nano(); break; - case PIPE_QUERY_PRIMITIVES_GENERATED: - case PIPE_QUERY_PRIMITIVES_EMITTED: + case PIPE_QUERY_PIPELINE_STATISTICS: + pq->end[task->thread_index] += + task->thread_data.ps_invocations - pq->start[task->thread_index]; + pq->start[task->thread_index] = 0; break; default: assert(0); break; } - - if (task->query[pq->type] == pq) { - task->query[pq->type] = NULL; - } } @@ -499,10 +586,8 @@ lp_rast_tile_end(struct lp_rasterizer_task *task) { unsigned i; - for (i = 0; i < PIPE_QUERY_TYPES; ++i) { - if (task->query[i]) { - lp_rast_end_query(task, lp_rast_arg_query(task->query[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])); } /* debug */ @@ -532,18 +617,41 @@ static lp_rast_cmd_func dispatch[LP_RAST_OP_MAX] = 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, + lp_rast_triangle_ms_1, + lp_rast_triangle_ms_2, + lp_rast_triangle_ms_3, + lp_rast_triangle_ms_4, + lp_rast_triangle_ms_5, + lp_rast_triangle_ms_6, + lp_rast_triangle_ms_7, + lp_rast_triangle_ms_8, + lp_rast_triangle_ms_3_4, + lp_rast_triangle_ms_3_16, + lp_rast_triangle_ms_4_16, }; static void do_rasterize_bin(struct lp_rasterizer_task *task, - const struct cmd_bin *bin) + const struct cmd_bin *bin, + int x, int y) { const struct cmd_block *block; unsigned k; if (0) - lp_debug_bin(bin); + lp_debug_bin(bin, x, y); for (block = bin->head; block; block = block->next) { for (k = 0; k < block->count; k++) { @@ -562,15 +670,15 @@ do_rasterize_bin(struct lp_rasterizer_task *task, */ static void rasterize_bin(struct lp_rasterizer_task *task, - const struct cmd_bin *bin ) + const struct cmd_bin *bin, int x, int y ) { - lp_rast_tile_begin( task, bin ); + lp_rast_tile_begin( task, bin, x, y ); - do_rasterize_bin(task, bin); + do_rasterize_bin(task, bin, x, y); lp_rast_tile_end(task); - +#ifdef DEBUG /* Debug/Perf flags: */ if (bin->head->count == 1) { @@ -579,6 +687,7 @@ rasterize_bin(struct lp_rasterizer_task *task, else if (bin->head->cmd[0] == LP_RAST_OP_SHADE_TILE) LP_COUNT(nr_pure_shade_64); } +#endif } @@ -606,32 +715,46 @@ rasterize_scene(struct lp_rasterizer_task *task, { task->scene = scene; - if (!task->rast->no_rast && !scene->discard) { + /* 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) { /* 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); - } - } - } -#else { struct cmd_bin *bin; + int i, j; assert(scene); - while ((bin = lp_scene_bin_iter_next(scene))) { + while ((bin = lp_scene_bin_iter_next(scene, &i, &j))) { if (!is_empty_bin( bin )) - rasterize_bin(task, bin); + rasterize_bin(task, bin, i, j); } } -#endif } +#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); } @@ -651,6 +774,12 @@ 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 ); @@ -658,6 +787,8 @@ lp_rast_queue_scene( struct lp_rasterizer *rast, lp_rast_end( rast ); + util_fpstate_set(fpstate); + rast->curr_scene = NULL; } else { @@ -700,11 +831,23 @@ lp_rast_finish( struct lp_rasterizer *rast ) * 2. do work * 3. signal that we're done */ -static PIPE_THREAD_ROUTINE( thread_function, 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; + + 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 */ @@ -727,7 +870,7 @@ static PIPE_THREAD_ROUTINE( thread_function, 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) @@ -737,7 +880,7 @@ static PIPE_THREAD_ROUTINE( thread_function, 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: */ @@ -752,7 +895,11 @@ static PIPE_THREAD_ROUTINE( thread_function, init_data ) pipe_semaphore_signal(&task->work_done); } - return NULL; +#ifdef _WIN32 + pipe_semaphore_signal(&task->work_done); +#endif + + return 0; } @@ -768,8 +915,12 @@ 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_function, + rast->threads[i] = u_thread_create(thread_function, (void *) &rast->tasks[i]); + if (!rast->threads[i]) { + rast->num_threads = i; /* previous thread is max */ + break; + } } } @@ -796,10 +947,15 @@ lp_rast_create( unsigned num_threads ) 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; @@ -809,14 +965,22 @@ lp_rast_create( unsigned num_threads ) 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); + 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: @@ -839,9 +1003,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 */ @@ -849,9 +1019,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); @@ -859,11 +1034,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; -} - -