AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

llvmpipe: repartition lp_rasterizer state for threading

Browse Source 
Some of the state is per-thread.  Put that state in new lp_rasterizer_task
struct.
This commit is contained in:
Brian Paul
2009-12-07 17:02:17 -07:00
parent cdaea049c9
commit 3a06c113c7
5 changed files with 133 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gallium/drivers/llvmpipe/lp_bin.h
+3 -1
View File
@@ -56,7 +56,9 @@
/* switch to a non-pointer value for this:
*/
typedef void (*lp_rast_cmd)( struct lp_rasterizer *, const union lp_rast_cmd_arg );
typedef void (*lp_rast_cmd)( struct lp_rasterizer *,
unsigned thread_index,
const union lp_rast_cmd_arg );
struct cmd_block {
lp_rast_cmd cmd[CMD_BLOCK_MAX];
src/gallium/drivers/llvmpipe/lp_rast.c
+60 -29
View File
@@ -39,14 +39,18 @@
struct lp_rasterizer *lp_rast_create( struct pipe_screen *screen )
{
struct lp_rasterizer *rast;
unsigned i;
rast = CALLOC_STRUCT(lp_rasterizer);
if(!rast)
return NULL;
rast->screen = screen;
rast->tile.color = align_malloc( TILE_SIZE*TILE_SIZE*4, 16 );
rast->tile.depth = align_malloc( TILE_SIZE*TILE_SIZE*4, 16 );
for (i = 0; i < Elements(rast->tasks); i++) {
rast->tasks[i].tile.color = align_malloc( TILE_SIZE*TILE_SIZE*4, 16 );
rast->tasks[i].tile.depth = align_malloc( TILE_SIZE*TILE_SIZE*4, 16 );
}
return rast;
}
@@ -153,12 +157,13 @@ lp_rast_end( struct lp_rasterizer *rast )
*/
static void
lp_rast_start_tile( struct lp_rasterizer *rast,
unsigned thread_index,
unsigned x, unsigned y )
{
LP_DBG(DEBUG_RAST, "%s %d,%d\n", __FUNCTION__, x, y);
rast->x = x;
rast->y = y;
rast->tasks[thread_index].x = x;
rast->tasks[thread_index].y = y;
}
@@ -167,9 +172,11 @@ lp_rast_start_tile( struct lp_rasterizer *rast,
* This is a bin command called during bin processing.
*/
void lp_rast_clear_color( struct lp_rasterizer *rast,
unsigned thread_index,
const union lp_rast_cmd_arg arg )
{
const uint8_t *clear_color = arg.clear_color;
uint8_t *color_tile = rast->tasks[thread_index].tile.color;
LP_DBG(DEBUG_RAST, "%s 0x%x,0x%x,0x%x,0x%x\n", __FUNCTION__,
clear_color[0],
@@ -180,14 +187,14 @@ void lp_rast_clear_color( struct lp_rasterizer *rast,
if (clear_color[0] == clear_color[1] &&
clear_color[1] == clear_color[2] &&
clear_color[2] == clear_color[3]) {
memset(rast->tile.color, clear_color[0], TILE_SIZE * TILE_SIZE * 4);
memset(color_tile, clear_color[0], TILE_SIZE * TILE_SIZE * 4);
}
else {
unsigned x, y, chan;
for (y = 0; y < TILE_SIZE; y++)
for (x = 0; x < TILE_SIZE; x++)
for (chan = 0; chan < 4; ++chan)
TILE_PIXEL(rast->tile.color, x, y, chan) = clear_color[chan];
TILE_PIXEL(color_tile, x, y, chan) = clear_color[chan];
}
}
@@ -197,15 +204,17 @@ void lp_rast_clear_color( struct lp_rasterizer *rast,
* This is a bin command called during bin processing.
*/
void lp_rast_clear_zstencil( struct lp_rasterizer *rast,
unsigned thread_index,
const union lp_rast_cmd_arg arg)
{
unsigned i, j;
uint32_t *depth_tile = rast->tasks[thread_index].tile.depth;
LP_DBG(DEBUG_RAST, "%s 0x%x\n", __FUNCTION__, arg.clear_zstencil);
for (i = 0; i < TILE_SIZE; i++)
for (j = 0; j < TILE_SIZE; j++)
rast->tile.depth[i*TILE_SIZE + j] = arg.clear_zstencil;
depth_tile[i*TILE_SIZE + j] = arg.clear_zstencil;
}
@@ -214,6 +223,7 @@ void lp_rast_clear_zstencil( struct lp_rasterizer *rast,
* This is a bin command called during bin processing.
*/
void lp_rast_load_color( struct lp_rasterizer *rast,
unsigned thread_index,
const union lp_rast_cmd_arg arg)
{
LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
@@ -227,6 +237,7 @@ void lp_rast_load_color( struct lp_rasterizer *rast,
* This is a bin command called during bin processing.
*/
void lp_rast_load_zstencil( struct lp_rasterizer *rast,
unsigned thread_index,
const union lp_rast_cmd_arg arg )
{
LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
@@ -236,6 +247,7 @@ void lp_rast_load_zstencil( struct lp_rasterizer *rast,
void lp_rast_set_state( struct lp_rasterizer *rast,
unsigned thread_index,
const union lp_rast_cmd_arg arg )
{
const struct lp_rast_state *state = arg.set_state;
@@ -243,7 +255,7 @@ void lp_rast_set_state( struct lp_rasterizer *rast,
LP_DBG(DEBUG_RAST, "%s %p\n", __FUNCTION__, (void *) state);
/* just set the current state pointer for this rasterizer */
rast->current_state = state;
rast->tasks[thread_index].current_state = state;
}
@@ -257,9 +269,12 @@ void lp_rast_set_state( struct lp_rasterizer *rast,
* This is a bin command called during bin processing.
*/
void lp_rast_shade_tile( struct lp_rasterizer *rast,
unsigned thread_index,
const union lp_rast_cmd_arg arg )
{
const struct lp_rast_shader_inputs *inputs = arg.shade_tile;
const unsigned tile_x = rast->tasks[thread_index].x;
const unsigned tile_y = rast->tasks[thread_index].y;
const unsigned mask = ~0;
unsigned x, y;
@@ -269,7 +284,12 @@ void lp_rast_shade_tile( struct lp_rasterizer *rast,
*/
for (y = 0; y < TILE_SIZE; y += 4)
for (x = 0; x < TILE_SIZE; x += 4)
lp_rast_shade_quads( rast, inputs, rast->x + x, rast->y + y, mask);
lp_rast_shade_quads( rast,
thread_index,
inputs,
tile_x + x,
tile_y + y,
mask);
}
@@ -278,13 +298,14 @@ void lp_rast_shade_tile( struct lp_rasterizer *rast,
* This is a bin command called during bin processing.
*/
void lp_rast_shade_quads( struct lp_rasterizer *rast,
unsigned thread_index,
const struct lp_rast_shader_inputs *inputs,
unsigned x, unsigned y,
unsigned mask)
{
#if 1
const struct lp_rast_state *state = rast->current_state;
struct lp_rast_tile *tile = &rast->tile;
const struct lp_rast_state *state = rast->tasks[thread_index].current_state;
struct lp_rast_tile *tile = &rast->tasks[thread_index].tile;
void *color;
void *depth;
uint32_t ALIGN16_ATTRIB masks[2][2][2][2];
@@ -388,10 +409,11 @@ void lp_rast_shade_quads( struct lp_rasterizer *rast,
/**
* Write the rasterizer's color tile to the framebuffer.
*/
static void lp_rast_store_color( struct lp_rasterizer *rast )
static void lp_rast_store_color( struct lp_rasterizer *rast,
unsigned thread_index)
{
const unsigned x = rast->x;
const unsigned y = rast->y;
const unsigned x = rast->tasks[thread_index].x;
const unsigned y = rast->tasks[thread_index].y;
unsigned w = TILE_SIZE;
unsigned h = TILE_SIZE;
@@ -404,7 +426,7 @@ static void lp_rast_store_color( struct lp_rasterizer *rast )
LP_DBG(DEBUG_RAST, "%s %d,%d %dx%d\n", __FUNCTION__, x, y, w, h);
lp_tile_write_4ub(rast->cbuf_transfer->format,
rast->tile.color,
rast->tasks[thread_index].tile.color,
rast->cbuf_map,
rast->cbuf_transfer->stride,
x, y,
@@ -430,10 +452,11 @@ lp_tile_write_z32(const uint32_t *src, uint8_t *dst, unsigned dst_stride,
/**
* Write the rasterizer's z/stencil tile to the framebuffer.
*/
static void lp_rast_store_zstencil( struct lp_rasterizer *rast )
static void lp_rast_store_zstencil( struct lp_rasterizer *rast,
unsigned thread_index )
{
const unsigned x = rast->x;
const unsigned y = rast->y;
const unsigned x = rast->tasks[thread_index].x;
const unsigned y = rast->tasks[thread_index].y;
unsigned w = TILE_SIZE;
unsigned h = TILE_SIZE;
@@ -446,7 +469,7 @@ static void lp_rast_store_zstencil( struct lp_rasterizer *rast )
LP_DBG(DEBUG_RAST, "%s %d,%d %dx%d\n", __FUNCTION__, x, y, w, h);
assert(rast->zsbuf_transfer->format == PIPE_FORMAT_Z32_UNORM);
lp_tile_write_z32(rast->tile.depth,
lp_tile_write_z32(rast->tasks[thread_index].tile.depth,
rast->zsbuf_map,
rast->zsbuf_transfer->stride,
x, y, w, h);
@@ -457,15 +480,16 @@ static void lp_rast_store_zstencil( struct lp_rasterizer *rast )
* Write the rasterizer's tiles to the framebuffer.
*/
static void
lp_rast_end_tile( struct lp_rasterizer *rast )
lp_rast_end_tile( struct lp_rasterizer *rast,
unsigned thread_index )
{
LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
if (rast->state.write_color)
lp_rast_store_color(rast);
lp_rast_store_color(rast, thread_index);
if (rast->state.write_zstencil)
lp_rast_store_zstencil(rast);
lp_rast_store_zstencil(rast, thread_index);
}
@@ -476,6 +500,7 @@ lp_rast_end_tile( struct lp_rasterizer *rast )
*/
static void
rasterize_bin( struct lp_rasterizer *rast,
unsigned thread_index,
const struct cmd_bin *bin,
int x, int y)
{
@@ -483,16 +508,16 @@ rasterize_bin( struct lp_rasterizer *rast,
struct cmd_block *block;
unsigned k;
lp_rast_start_tile( rast, x, y );
lp_rast_start_tile( rast, thread_index, 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]( rast, block->arg[k] );
block->cmd[k]( rast, 0, block->arg[k] );
}
}
lp_rast_end_tile( rast );
lp_rast_end_tile( rast, thread_index );
}
@@ -522,7 +547,7 @@ lp_rasterize_bins( struct lp_rasterizer *rast,
for (i = 0; i < bins->tiles_x; i++) {
for (j = 0; j < bins->tiles_y; j++) {
struct cmd_bin *bin = lp_get_bin(bins, i, j);
rasterize_bin( rast, bin, i * TILE_SIZE, j * TILE_SIZE );
rasterize_bin( rast, 0, bin, i * TILE_SIZE, j * TILE_SIZE );
}
}
}
@@ -534,7 +559,7 @@ lp_rasterize_bins( struct lp_rasterizer *rast,
lp_bin_iter_begin( bins );
while ((bin = lp_bin_iter_next(bins, &x, &y))) {
rasterize_bin( rast, bin, x * TILE_SIZE, y * TILE_SIZE);
rasterize_bin( rast, 0, bin, x * TILE_SIZE, y * TILE_SIZE);
}
}
#endif
@@ -550,10 +575,16 @@ lp_rasterize_bins( struct lp_rasterizer *rast,
*/
void lp_rast_destroy( struct lp_rasterizer *rast )
{
unsigned i;
pipe_surface_reference(&rast->state.cbuf, NULL);
pipe_surface_reference(&rast->state.zsbuf, NULL);
align_free(rast->tile.depth);
align_free(rast->tile.color);
for (i = 0; i < Elements(rast->tasks); i++) {
align_free(rast->tasks[i].tile.depth);
align_free(rast->tasks[i].tile.color);
}
FREE(rast);
}
src/gallium/drivers/llvmpipe/lp_rast.h
+7
View File
@@ -193,24 +193,31 @@ lp_rast_arg_null( void )
*/
void lp_rast_clear_color( struct lp_rasterizer *,
unsigned thread_index,
const union lp_rast_cmd_arg );
void lp_rast_clear_zstencil( struct lp_rasterizer *,
unsigned thread_index,
const union lp_rast_cmd_arg );
void lp_rast_load_color( struct lp_rasterizer *,
unsigned thread_index,
const union lp_rast_cmd_arg );
void lp_rast_load_zstencil( struct lp_rasterizer *,
unsigned thread_index,
const union lp_rast_cmd_arg );
void lp_rast_set_state( struct lp_rasterizer *,
unsigned thread_index,
const union lp_rast_cmd_arg );
void lp_rast_triangle( struct lp_rasterizer *,
unsigned thread_index,
const union lp_rast_cmd_arg );
void lp_rast_shade_tile( struct lp_rasterizer *,
unsigned thread_index,
const union lp_rast_cmd_arg );
src/gallium/drivers/llvmpipe/lp_rast_priv.h
+30 -13
View File
@@ -30,6 +30,10 @@
#include "lp_rast.h"
#define MAX_THREADS 4 /* XXX probably temporary here */
struct pipe_transfer;
struct pipe_screen;
@@ -47,14 +51,34 @@ struct lp_rast_tile
/**
* This is the state required while rasterizing a tile.
* The tile size is TILE_SIZE x TILE_SIZE pixels.
* Per-thread rasterization state
*/
struct lp_rasterizer
struct lp_rasterizer_task
{
struct lp_rast_tile tile; /** Tile color/z/stencil memory */
unsigned x, y; /**< Pos of this tile in framebuffer, in pixels */
/* Pixel blocks produced during rasterization
*/
unsigned nr_blocks;
struct {
unsigned x;
unsigned y;
unsigned mask;
} blocks[256];
const struct lp_rast_state *current_state;
};
/**
* This is the state required while rasterizing tiles.
* Note that this contains per-thread information too.
* The tile size is TILE_SIZE x TILE_SIZE pixels.
*/
struct lp_rasterizer
{
unsigned width, height; /**< Size of framebuffer, in pixels */
boolean clipped_tile;
@@ -78,20 +102,13 @@ struct lp_rasterizer
char clear_stencil;
} state;
/* Pixel blocks produced during rasterization
*/
unsigned nr_blocks;
struct {
unsigned x;
unsigned y;
unsigned mask;
} blocks[256];
const struct lp_rast_state *current_state;
/** A task object for each rasterization thread */
struct lp_rasterizer_task tasks[MAX_THREADS];
};
void lp_rast_shade_quads( struct lp_rasterizer *rast,
unsigned thread_index,
const struct lp_rast_shader_inputs *inputs,
unsigned x, unsigned y,
unsigned masks);
src/gallium/drivers/llvmpipe/lp_rast_tri.c
+33 -29
View File
@@ -40,15 +40,15 @@
* All pixels are known to be inside the triangle's bounds.
*/
static void
block_full_4( struct lp_rasterizer *rast, int x, int y )
block_full_4( struct lp_rasterizer_task *rast_task, int x, int y )
{
const unsigned i = rast->nr_blocks;
const unsigned i = rast_task->nr_blocks;
assert(x % 4 == 0);
assert(y % 4 == 0);
rast->blocks[i].x = x;
rast->blocks[i].y = y;
rast->blocks[i].mask = ~0;
rast->nr_blocks++;
rast_task->blocks[i].x = x;
rast_task->blocks[i].y = y;
rast_task->blocks[i].mask = ~0;
rast_task->nr_blocks++;
}
@@ -57,14 +57,14 @@ block_full_4( struct lp_rasterizer *rast, int x, int y )
* All pixels are known to be inside the triangle's bounds.
*/
static void
block_full_16( struct lp_rasterizer *rast, int x, int y )
block_full_16( struct lp_rasterizer_task *rast_task, int x, int y )
{
unsigned ix, iy;
assert(x % 16 == 0);
assert(y % 16 == 0);
for (iy = 0; iy < 16; iy += 4)
for (ix = 0; ix < 16; ix += 4)
block_full_4(rast, x + ix, y + iy);
block_full_4(rast_task, x + ix, y + iy);
}
@@ -74,7 +74,7 @@ block_full_16( struct lp_rasterizer *rast, int x, int y )
* Generate a mask of in/out flags and add the block to the blocks list.
*/
static void
do_block_4( struct lp_rasterizer *rast,
do_block_4( struct lp_rasterizer_task *rast_task,
const struct lp_rast_triangle *tri,
int x, int y,
int c1,
@@ -97,11 +97,11 @@ do_block_4( struct lp_rasterizer *rast,
/* As we do trivial reject already, masks should rarely be all zero:
*/
if (mask) {
const unsigned i = rast->nr_blocks;
rast->blocks[i].x = x;
rast->blocks[i].y = y;
rast->blocks[i].mask = mask;
rast->nr_blocks++;
const unsigned i = rast_task->nr_blocks;
rast_task->blocks[i].x = x;
rast_task->blocks[i].y = y;
rast_task->blocks[i].mask = mask;
rast_task->nr_blocks++;
}
}
@@ -111,7 +111,7 @@ do_block_4( struct lp_rasterizer *rast,
* of the triangle's bounds.
*/
static void
do_block_16( struct lp_rasterizer *rast,
do_block_16( struct lp_rasterizer_task *rast_task,
const struct lp_rast_triangle *tri,
int x, int y,
int c1,
@@ -146,11 +146,11 @@ do_block_16( struct lp_rasterizer *rast,
cx2 + ei2 > 0 &&
cx3 + ei3 > 0) {
/* the block is completely inside the triangle */
block_full_4(rast, x+ix, y+iy);
block_full_4(rast_task, x+ix, y+iy);
}
else {
/* the block is partially in/out of the triangle */
do_block_4(rast, tri, x+ix, y+iy, cx1, cx2, cx3);
do_block_4(rast_task, tri, x+ix, y+iy, cx1, cx2, cx3);
}
}
}
@@ -163,12 +163,14 @@ do_block_16( struct lp_rasterizer *rast,
*/
void
lp_rast_triangle( struct lp_rasterizer *rast,
unsigned thread_index,
const union lp_rast_cmd_arg arg )
{
struct lp_rasterizer_task *rast_task = &rast->tasks[thread_index];
const struct lp_rast_triangle *tri = arg.triangle;
int x = rast->x;
int y = rast->y;
int x = rast_task->x;
int y = rast_task->y;
int ix, iy;
unsigned i = 0;
@@ -184,11 +186,11 @@ lp_rast_triangle( struct lp_rasterizer *rast,
int eo2 = tri->eo2 * 16;
int eo3 = tri->eo3 * 16;
assert(Elements(rast->blocks) == (TILE_SIZE * TILE_SIZE) / (4*4));
assert(Elements(rast_task->blocks) == (TILE_SIZE * TILE_SIZE) / (4*4));
LP_DBG(DEBUG_RAST, "lp_rast_triangle\n");
rast->nr_blocks = 0;
rast_task->nr_blocks = 0;
/* Walk over the tile to build a list of 4x4 pixel blocks which will
* be filled/shaded. We do this at two granularities: 16x16 blocks
@@ -209,21 +211,23 @@ lp_rast_triangle( struct lp_rasterizer *rast,
cx2 + ei2 > 0 &&
cx3 + ei3 > 0) {
/* the block is completely inside the triangle */
block_full_16(rast, x+ix, y+iy);
block_full_16(rast_task, x+ix, y+iy);
}
else {
/* the block is partially in/out of the triangle */
do_block_16(rast, tri, x+ix, y+iy, cx1, cx2, cx3);
do_block_16(rast_task, tri, x+ix, y+iy, cx1, cx2, cx3);
}
}
}
assert(rast->nr_blocks <= Elements(rast->blocks));
assert(rast_task->nr_blocks <= Elements(rast_task->blocks));
/* Shade the 4x4 pixel blocks */
for (i = 0; i < rast->nr_blocks; i++)
lp_rast_shade_quads(rast, &tri->inputs,
rast->blocks[i].x,
rast->blocks[i].y,
rast->blocks[i].mask);
for (i = 0; i < rast_task->nr_blocks; i++)
lp_rast_shade_quads(rast,
thread_index,
&tri->inputs,
rast_task->blocks[i].x,
rast_task->blocks[i].y,
rast_task->blocks[i].mask);
}