[Intel-gfx] [PATCH] lib/igt_draw: Add Y-tiling support

Praveen Paneri praveen.paneri at intel.com
Fri Jul 14 14:02:35 UTC 2017



On Friday 14 July 2017 03:03 AM, Paulo Zanoni wrote:
> Em Sex, 2017-06-09 às 15:48 +0530, Praveen Paneri escreveu:
>> This patch adds Y-tiling support for igt_draw_rect function.
>>
>> v2: Use helper function to get tile sizes (Ville)
>>
>> v3: Moved igt_get_fb_tile_size() out of the for loop
>>  for better performance (Paulo)
>
> For some reason I thought this series was using my original patch, but
> I realized it's not:
>
> https://patchwork.freedesktop.org/patch/72039/
>
> Now that I read our past emails, I wonder that maybe I didn't send you
> this specific patch of that series. I'm sorry for that. Obviously I'm
> biased towards my version. Which one do you think is better? Would you
> be willing to give my version a r-b, in case you think it's better?
Your version looks better. I will add my r-b and post it
Thanks
Praveen
>
> Thanks,
> Paulo
>
>
>>
>> Signed-off-by: Praveen Paneri <praveen.paneri at intel.com>
>> ---
>>  lib/igt_draw.c | 139 ++++++++++++++++++++++++++++++++++++++---------
>> ----------
>>  1 file changed, 94 insertions(+), 45 deletions(-)
>>
>> diff --git a/lib/igt_draw.c b/lib/igt_draw.c
>> index 29aec85..2138bf7 100644
>> --- a/lib/igt_draw.c
>> +++ b/lib/igt_draw.c
>> @@ -136,32 +136,45 @@ static int swizzle_addr(int addr, int swizzle)
>>
>>  /* It's all in "pixel coordinates", so make sure you multiply/divide
>> by the bpp
>>   * if you need to. */
>> -static int linear_x_y_to_tiled_pos(int x, int y, uint32_t stride,
>> int swizzle,
>> -				   int bpp)
>> +static int linear_x_y_to_tiled_pos(int fd, int x, int y, uint32_t
>> stride, int swizzle,
>> +				   int bpp, int tiling, uint32_t
>> tile_width,
>> +				   uint32_t tile_height)
>>  {
>> -	int x_tile_size, y_tile_size;
>> -	int x_tile_n, y_tile_n, x_tile_off, y_tile_off;
>> -	int line_size, tile_size;
>> +	uint32_t tile_size;
>> +	int tile_x, tile_y; /* Co-ordinates of the tile holding the
>> pixel */
>> +	int tile_x_off, tile_y_off; /* pixel position inside the
>> tile */
>>  	int tile_n, tile_off;
>> -	int tiled_pos, tiles_per_line;
>> +	int line_size, tiles_per_line;
>> +	int tiled_pos;
>>  	int pixel_size = bpp / 8;
>>
>>  	line_size = stride;
>> -	x_tile_size = 512;
>> -	y_tile_size = 8;
>> -	tile_size = x_tile_size * y_tile_size;
>> -	tiles_per_line = line_size / x_tile_size;
>> +	tile_size = tile_width * tile_height;
>> +	tiles_per_line = line_size / tile_width;
>>
>> -	y_tile_n = y / y_tile_size;
>> -	y_tile_off = y % y_tile_size;
>> +	tile_y = y / tile_height;
>> +	tile_y_off = y % tile_height;
>>
>> -	x_tile_n = (x * pixel_size) / x_tile_size;
>> -	x_tile_off = (x * pixel_size) % x_tile_size;
>> +	tile_x = (x * pixel_size) / tile_width;
>> +	tile_x_off = (x * pixel_size) % tile_width;
>>
>> -	tile_n = y_tile_n * tiles_per_line + x_tile_n;
>> -	tile_off = y_tile_off * x_tile_size + x_tile_off;
>> -	tiled_pos = tile_n * tile_size + tile_off;
>> +	tile_n = tile_y * tiles_per_line + tile_x;
>> +
>> +	if (tiling == I915_TILING_X ) {
>> +		tile_off = tile_y_off * tile_width + tile_x_off;
>> +	} else { /* (tiling == I915_TILING_Y ) */
>> +		int x_oword_n, x_oword_off;
>> +		int oword_size = 16;
>> +
>> +		/* computation inside the tile */
>> +		x_oword_n = tile_x_off / oword_size;
>> +		x_oword_off = tile_x_off % oword_size;
>> +		tile_off = x_oword_n * tile_height * oword_size
>> +			   + tile_y_off * oword_size
>> +			   + x_oword_off;
>> +	}
>>
>> +	tiled_pos = tile_n * tile_size + tile_off;
>>  	tiled_pos = swizzle_addr(tiled_pos, swizzle);
>>
>>  	return tiled_pos / pixel_size;
>> @@ -169,34 +182,48 @@ static int linear_x_y_to_tiled_pos(int x, int
>> y, uint32_t stride, int swizzle,
>>
>>  /* It's all in "pixel coordinates", so make sure you multiply/divide
>> by the bpp
>>   * if you need to. */
>> -static void tiled_pos_to_x_y_linear(int tiled_pos, uint32_t stride,
>> -				    int swizzle, int bpp, int *x,
>> int *y)
>> +static void tiled_pos_to_x_y_linear(int fd, int tiled_pos, uint32_t
>> stride,
>> +				    int swizzle, int bpp, int *x,
>> int *y,
>> +				    int tiling, uint32_t tile_width,
>> +				    uint32_t tile_height)
>>  {
>> -	int tile_n, tile_off, tiles_per_line, line_size;
>> -	int x_tile_off, y_tile_off;
>> -	int x_tile_n, y_tile_n;
>> -	int x_tile_size, y_tile_size, tile_size;
>> +	uint32_t tile_size;
>> +	int tile_x, tile_y; /* Co-ordinates of the tile holding the
>> pixel */
>> +	int tile_x_off, tile_y_off; /* pixel position inside the
>> tile */
>> +	int tile_n, tile_off;
>> +	int line_size, tiles_per_line;
>>  	int pixel_size = bpp / 8;
>>
>>  	tiled_pos = swizzle_addr(tiled_pos, swizzle);
>>
>>  	line_size = stride;
>> -	x_tile_size = 512;
>> -	y_tile_size = 8;
>> -	tile_size = x_tile_size * y_tile_size;
>> -	tiles_per_line = line_size / x_tile_size;
>> +	tile_size = tile_width * tile_height;
>> +	tiles_per_line = line_size / tile_width;
>>
>>  	tile_n = tiled_pos / tile_size;
>>  	tile_off = tiled_pos % tile_size;
>>
>> -	y_tile_off = tile_off / x_tile_size;
>> -	x_tile_off = tile_off % x_tile_size;
>> +	tile_x = tile_n % tiles_per_line;
>> +	tile_y = tile_n / tiles_per_line;
>> +
>> +	if (tiling == I915_TILING_X ) {
>> +
>> +		tile_y_off = tile_off / tile_width;
>> +		tile_x_off = tile_off % tile_width;
>> +	} else {
>> +		int x_oword_n, x_oword_off;
>> +		int oword_size = 16;
>> +
>> +		x_oword_n = tile_off / (oword_size * tile_height);
>> +		x_oword_off = tile_off % oword_size;
>>
>> -	x_tile_n = tile_n % tiles_per_line;
>> -	y_tile_n = tile_n / tiles_per_line;
>> +		tile_x_off = x_oword_n * oword_size + x_oword_off;
>> +		tile_y_off = (tile_off - x_oword_n * oword_size *
>> tile_height)
>> +			     / oword_size;
>> +	}
>>
>> -	*x = (x_tile_n * x_tile_size + x_tile_off) / pixel_size;
>> -	*y = y_tile_n * y_tile_size + y_tile_off;
>> +	*x = (tile_x * tile_width + tile_x_off) / pixel_size;
>> +	*y = tile_y * tile_height + tile_y_off;
>>  }
>>
>>  static void set_pixel(void *_ptr, int index, uint32_t color, int
>> bpp)
>> @@ -224,15 +251,21 @@ static void draw_rect_ptr_linear(void *ptr,
>> uint32_t stride,
>>  	}
>>  }
>>
>> -static void draw_rect_ptr_tiled(void *ptr, uint32_t stride, int
>> swizzle,
>> -				struct rect *rect, uint32_t color,
>> int bpp)
>> +static void draw_rect_ptr_tiled(int fd, void *ptr, uint32_t stride,
>> int swizzle,
>> +				struct rect *rect, uint32_t color,
>> int bpp,
>> +				int tiling)
>>  {
>>  	int x, y, pos;
>> +	uint32_t tile_width, tile_height;
>> +
>> +	igt_get_fb_tile_size(fd,
>> (uint64_t)igt_fb_tiling_to_mod(tiling), bpp,
>> +			&tile_width, &tile_height);
>>
>>  	for (y = rect->y; y < rect->y + rect->h; y++) {
>>  		for (x = rect->x; x < rect->x + rect->w; x++) {
>> -			pos = linear_x_y_to_tiled_pos(x, y, stride,
>> swizzle,
>> -						      bpp);
>> +			pos = linear_x_y_to_tiled_pos(fd, x, y,
>> stride, swizzle,
>> +						      bpp, tiling,
>> tile_width,
>> +						      tile_height);
>>  			set_pixel(ptr, pos, color, bpp);
>>  		}
>>  	}
>> @@ -259,8 +292,12 @@ static void draw_rect_mmap_cpu(int fd, struct
>> buf_data *buf, struct rect *rect,
>>  		draw_rect_ptr_linear(ptr, buf->stride, rect, color,
>> buf->bpp);
>>  		break;
>>  	case I915_TILING_X:
>> -		draw_rect_ptr_tiled(ptr, buf->stride, swizzle, rect,
>> color,
>> -				    buf->bpp);
>> +		draw_rect_ptr_tiled(fd, ptr, buf->stride, swizzle,
>> rect, color,
>> +				    buf->bpp, tiling);
>> +		break;
>> +	case I915_TILING_Y:
>> +		draw_rect_ptr_tiled(fd, ptr, buf->stride, swizzle,
>> rect, color,
>> +				    buf->bpp, tiling);
>>  		break;
>>  	default:
>>  		igt_assert(false);
>> @@ -309,8 +346,12 @@ static void draw_rect_mmap_wc(int fd, struct
>> buf_data *buf, struct rect *rect,
>>  		draw_rect_ptr_linear(ptr, buf->stride, rect, color,
>> buf->bpp);
>>  		break;
>>  	case I915_TILING_X:
>> -		draw_rect_ptr_tiled(ptr, buf->stride, swizzle, rect,
>> color,
>> -				    buf->bpp);
>> +		draw_rect_ptr_tiled(fd, ptr, buf->stride, swizzle,
>> rect, color,
>> +				    buf->bpp, tiling);
>> +		break;
>> +	case I915_TILING_Y:
>> +		draw_rect_ptr_tiled(fd, ptr, buf->stride, swizzle,
>> rect, color,
>> +				    buf->bpp, tiling);
>>  		break;
>>  	default:
>>  		igt_assert(false);
>> @@ -338,7 +379,7 @@ static void draw_rect_pwrite_untiled(int fd,
>> struct buf_data *buf,
>>
>>  static void draw_rect_pwrite_tiled(int fd, struct buf_data *buf,
>>  				   struct rect *rect, uint32_t
>> color,
>> -				   uint32_t swizzle)
>> +				   uint32_t swizzle, int tiling)
>>  {
>>  	int i;
>>  	int tiled_pos, x, y, pixel_size;
>> @@ -347,6 +388,7 @@ static void draw_rect_pwrite_tiled(int fd, struct
>> buf_data *buf,
>>  	bool flush_tmp = false;
>>  	int tmp_start_pos = 0;
>>  	int pixels_written = 0;
>> +	uint32_t tile_width, tile_height;
>>
>>  	/* We didn't implement suport for the older tiling methods
>> yet. */
>>  	igt_require(intel_gen(intel_get_drm_devid(fd)) >= 5);
>> @@ -360,9 +402,13 @@ static void draw_rect_pwrite_tiled(int fd,
>> struct buf_data *buf,
>>  	for (i = 0; i < tmp_size; i++)
>>  		set_pixel(tmp, i, color, buf->bpp);
>>
>> +	igt_get_fb_tile_size(fd,
>> (uint64_t)igt_fb_tiling_to_mod(tiling),
>> +			     buf->bpp, &tile_width, &tile_height);
>> +
>>  	for (tiled_pos = 0; tiled_pos < buf->size; tiled_pos +=
>> pixel_size) {
>> -		tiled_pos_to_x_y_linear(tiled_pos, buf->stride,
>> swizzle,
>> -					buf->bpp, &x, &y);
>> +		tiled_pos_to_x_y_linear(fd, tiled_pos, buf->stride,
>> swizzle,
>> +					buf->bpp, &x, &y, tiling,
>> tile_width,
>> +					tile_height);
>>
>>  		if (x >= rect->x && x < rect->x + rect->w &&
>>  		    y >= rect->y && y < rect->y + rect->h) {
>> @@ -399,7 +445,10 @@ static void draw_rect_pwrite(int fd, struct
>> buf_data *buf,
>>  		draw_rect_pwrite_untiled(fd, buf, rect, color);
>>  		break;
>>  	case I915_TILING_X:
>> -		draw_rect_pwrite_tiled(fd, buf, rect, color,
>> swizzle);
>> +		draw_rect_pwrite_tiled(fd, buf, rect, color,
>> swizzle, tiling);
>> +		break;
>> +	case I915_TILING_Y:
>> +		draw_rect_pwrite_tiled(fd, buf, rect, color,
>> swizzle, tiling);
>>  		break;
>>  	default:
>>  		igt_assert(false);


More information about the Intel-gfx mailing list