X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Ffreedreno%2Ffreedreno_gmem.c;h=69fb16d058bdafe579c4bc4c568fd1d8eac477b9;hb=0b98e84e9ba082b9aa00b24fded3fb56224c6fc6;hp=68b4eb607a6b9da607be456bd44ca4c21c2c4b25;hpb=be01d7a905d827c3c0c222cab2430c6d4575429a;p=mesa.git

diff --git a/src/gallium/drivers/freedreno/freedreno_gmem.c b/src/gallium/drivers/freedreno/freedreno_gmem.c
index 68b4eb607a6..69fb16d058b 100644
--- a/src/gallium/drivers/freedreno/freedreno_gmem.c
+++ b/src/gallium/drivers/freedreno/freedreno_gmem.c
@@ -34,7 +34,9 @@
 
 #include "freedreno_gmem.h"
 #include "freedreno_context.h"
+#include "freedreno_fence.h"
 #include "freedreno_resource.h"
+#include "freedreno_query_hw.h"
 #include "freedreno_util.h"
 
 /*
@@ -66,91 +68,199 @@
  * resolve.
  */
 
+static uint32_t bin_width(struct fd_screen *screen)
+{
+	if (is_a4xx(screen) || is_a5xx(screen))
+		return 1024;
+	if (is_a3xx(screen))
+		return 992;
+	return 512;
+}
+
+static uint32_t
+total_size(uint8_t cbuf_cpp[], uint8_t zsbuf_cpp[2],
+		   uint32_t bin_w, uint32_t bin_h, struct fd_gmem_stateobj *gmem)
+{
+	uint32_t total = 0, i;
+
+	for (i = 0; i < MAX_RENDER_TARGETS; i++) {
+		if (cbuf_cpp[i]) {
+			gmem->cbuf_base[i] = align(total, 0x4000);
+			total = gmem->cbuf_base[i] + cbuf_cpp[i] * bin_w * bin_h;
+		}
+	}
+
+	if (zsbuf_cpp[0]) {
+		gmem->zsbuf_base[0] = align(total, 0x4000);
+		total = gmem->zsbuf_base[0] + zsbuf_cpp[0] * bin_w * bin_h;
+	}
+
+	if (zsbuf_cpp[1]) {
+		gmem->zsbuf_base[1] = align(total, 0x4000);
+		total = gmem->zsbuf_base[1] + zsbuf_cpp[1] * bin_w * bin_h;
+	}
+
+	return total;
+}
+
 static void
-calculate_tiles(struct fd_context *ctx)
+calculate_tiles(struct fd_batch *batch)
 {
+	struct fd_context *ctx = batch->ctx;
 	struct fd_gmem_stateobj *gmem = &ctx->gmem;
-	struct pipe_scissor_state *scissor = &ctx->max_scissor;
-	struct pipe_framebuffer_state *pfb = &ctx->framebuffer;
-	uint32_t gmem_size = ctx->screen->gmemsize_bytes;
+	struct pipe_scissor_state *scissor = &batch->max_scissor;
+	struct pipe_framebuffer_state *pfb = &batch->framebuffer;
+	const uint32_t gmem_alignment = ctx->screen->gmem_alignment;
+	const uint32_t gmem_size = ctx->screen->gmemsize_bytes;
 	uint32_t minx, miny, width, height;
 	uint32_t nbins_x = 1, nbins_y = 1;
 	uint32_t bin_w, bin_h;
-	uint32_t max_width = 992;
-	uint32_t cpp = 4;
-	uint32_t i, j, t, p, n, xoff, yoff;
-
-	if (pfb->cbufs[0])
-		cpp = util_format_get_blocksize(pfb->cbufs[0]->format);
+	uint32_t max_width = bin_width(ctx->screen);
+	uint8_t cbuf_cpp[MAX_RENDER_TARGETS] = {0}, zsbuf_cpp[2] = {0};
+	uint32_t i, j, t, xoff, yoff;
+	uint32_t tpp_x, tpp_y;
+	bool has_zs = !!(batch->resolve & (FD_BUFFER_DEPTH | FD_BUFFER_STENCIL));
+	int tile_n[ARRAY_SIZE(ctx->pipe)];
+
+	if (has_zs) {
+		struct fd_resource *rsc = fd_resource(pfb->zsbuf->texture);
+		zsbuf_cpp[0] = rsc->cpp;
+		if (rsc->stencil)
+			zsbuf_cpp[1] = rsc->stencil->cpp;
+	}
+	for (i = 0; i < pfb->nr_cbufs; i++) {
+		if (pfb->cbufs[i])
+			cbuf_cpp[i] = util_format_get_blocksize(pfb->cbufs[i]->format);
+		else
+			cbuf_cpp[i] = 4;
+	}
 
-	if ((gmem->cpp == cpp) &&
-			!memcmp(&gmem->scissor, scissor, sizeof(gmem->scissor))) {
+	if (!memcmp(gmem->zsbuf_cpp, zsbuf_cpp, sizeof(zsbuf_cpp)) &&
+		!memcmp(gmem->cbuf_cpp, cbuf_cpp, sizeof(cbuf_cpp)) &&
+		!memcmp(&gmem->scissor, scissor, sizeof(gmem->scissor))) {
 		/* everything is up-to-date */
 		return;
 	}
 
-	if (fd_mesa_debug & FD_DBG_DSCIS) {
+	if (fd_mesa_debug & FD_DBG_NOSCIS) {
 		minx = 0;
 		miny = 0;
 		width = pfb->width;
 		height = pfb->height;
 	} else {
-		minx = scissor->minx & ~31; /* round down to multiple of 32 */
-		miny = scissor->miny & ~31;
+		/* round down to multiple of alignment: */
+		minx = scissor->minx & ~(gmem_alignment - 1);
+		miny = scissor->miny & ~(gmem_alignment - 1);
 		width = scissor->maxx - minx;
 		height = scissor->maxy - miny;
 	}
 
-// TODO we probably could optimize this a bit if we know that
-// Z or stencil is not enabled for any of the draw calls..
-//	if (fd_stencil_enabled(ctx->zsa) || fd_depth_enabled(ctx->zsa)) {
-		gmem_size /= 2;
-		max_width = 256;
-//	}
-
-	bin_w = align(width, 32);
-	bin_h = align(height, 32);
+	bin_w = align(width, gmem_alignment);
+	bin_h = align(height, gmem_alignment);
 
 	/* first, find a bin width that satisfies the maximum width
 	 * restrictions:
 	 */
 	while (bin_w > max_width) {
 		nbins_x++;
-		bin_w = align(width / nbins_x, 32);
+		bin_w = align(width / nbins_x, gmem_alignment);
 	}
 
-	/* then find a bin height that satisfies the memory constraints:
+	if (fd_mesa_debug & FD_DBG_MSGS) {
+		debug_printf("binning input: cbuf cpp:");
+		for (i = 0; i < pfb->nr_cbufs; i++)
+			debug_printf(" %d", cbuf_cpp[i]);
+		debug_printf(", zsbuf cpp: %d; %dx%d\n",
+				zsbuf_cpp[0], width, height);
+	}
+
+	/* then find a bin width/height that satisfies the memory
+	 * constraints:
 	 */
-	while ((bin_w * bin_h * cpp) > gmem_size) {
-		nbins_y++;
-		bin_h = align(height / nbins_y, 32);
+	while (total_size(cbuf_cpp, zsbuf_cpp, bin_w, bin_h, gmem) > gmem_size) {
+		if (bin_w > bin_h) {
+			nbins_x++;
+			bin_w = align(width / nbins_x, gmem_alignment);
+		} else {
+			nbins_y++;
+			bin_h = align(height / nbins_y, gmem_alignment);
+		}
 	}
 
 	DBG("using %d bins of size %dx%d", nbins_x*nbins_y, bin_w, bin_h);
 
 	gmem->scissor = *scissor;
-	gmem->cpp = cpp;
+	memcpy(gmem->cbuf_cpp, cbuf_cpp, sizeof(cbuf_cpp));
+	memcpy(gmem->zsbuf_cpp, zsbuf_cpp, sizeof(zsbuf_cpp));
 	gmem->bin_h = bin_h;
 	gmem->bin_w = bin_w;
 	gmem->nbins_x = nbins_x;
 	gmem->nbins_y = nbins_y;
+	gmem->minx = minx;
+	gmem->miny = miny;
 	gmem->width = width;
 	gmem->height = height;
 
-	/* Assign tiles and pipes:
-	 * NOTE we currently take a rather simplistic approach of
-	 * mapping rows of tiles to a pipe.  At some point it might
-	 * be worth playing with different strategies and seeing if
-	 * that makes much impact on performance.
+	/*
+	 * Assign tiles and pipes:
+	 *
+	 * At some point it might be worth playing with different
+	 * strategies and seeing if that makes much impact on
+	 * performance.
 	 */
-	t = p = n = 0;
+
+#define div_round_up(v, a)  (((v) + (a) - 1) / (a))
+	/* figure out number of tiles per pipe: */
+	tpp_x = tpp_y = 1;
+	while (div_round_up(nbins_y, tpp_y) > 8)
+		tpp_y += 2;
+	while ((div_round_up(nbins_y, tpp_y) *
+			div_round_up(nbins_x, tpp_x)) > 8)
+		tpp_x += 1;
+
+	/* configure pipes: */
+	xoff = yoff = 0;
+	for (i = 0; i < ARRAY_SIZE(ctx->pipe); i++) {
+		struct fd_vsc_pipe *pipe = &ctx->pipe[i];
+
+		if (xoff >= nbins_x) {
+			xoff = 0;
+			yoff += tpp_y;
+		}
+
+		if (yoff >= nbins_y) {
+			break;
+		}
+
+		pipe->x = xoff;
+		pipe->y = yoff;
+		pipe->w = MIN2(tpp_x, nbins_x - xoff);
+		pipe->h = MIN2(tpp_y, nbins_y - yoff);
+
+		xoff += tpp_x;
+	}
+
+	for (; i < ARRAY_SIZE(ctx->pipe); i++) {
+		struct fd_vsc_pipe *pipe = &ctx->pipe[i];
+		pipe->x = pipe->y = pipe->w = pipe->h = 0;
+	}
+
+#if 0 /* debug */
+	printf("%dx%d ... tpp=%dx%d\n", nbins_x, nbins_y, tpp_x, tpp_y);
+	for (i = 0; i < 8; i++) {
+		struct fd_vsc_pipe *pipe = &ctx->pipe[i];
+		printf("pipe[%d]: %ux%u @ %u,%u\n", i,
+				pipe->w, pipe->h, pipe->x, pipe->y);
+	}
+#endif
+
+	/* configure tiles: */
+	t = 0;
 	yoff = miny;
+	memset(tile_n, 0, sizeof(tile_n));
 	for (i = 0; i < nbins_y; i++) {
-		struct fd_vsc_pipe *pipe = &ctx->pipe[p];
 		uint32_t bw, bh;
 
-		assert(p < ARRAY_SIZE(ctx->pipe));
-
 		xoff = minx;
 
 		/* clip bin height: */
@@ -158,13 +268,17 @@ calculate_tiles(struct fd_context *ctx)
 
 		for (j = 0; j < nbins_x; j++) {
 			struct fd_tile *tile = &ctx->tile[t];
+			uint32_t p;
 
 			assert(t < ARRAY_SIZE(ctx->tile));
 
+			/* pipe number: */
+			p = ((i / tpp_y) * div_round_up(nbins_x, tpp_x)) + (j / tpp_x);
+
 			/* clip bin width: */
 			bw = MIN2(bin_w, minx + width - xoff);
 
-			tile->n = n++;
+			tile->n = tile_n[p]++;
 			tile->p = p;
 			tile->bin_w = bw;
 			tile->bin_h = bh;
@@ -176,31 +290,32 @@ calculate_tiles(struct fd_context *ctx)
 			xoff += bw;
 		}
 
-		/* one pipe per row: */
-		pipe->x = 0;
-		pipe->y = i;
-		pipe->w = nbins_x;
-		pipe->h = 1;
-
-		p++;
-		n = 0;
-
 		yoff += bh;
 	}
 
-	for (; p < ARRAY_SIZE(ctx->pipe); p++) {
-		struct fd_vsc_pipe *pipe = &ctx->pipe[p];
-		pipe->x = pipe->y = pipe->w = pipe->h = 0;
+#if 0 /* debug */
+	t = 0;
+	for (i = 0; i < nbins_y; i++) {
+		for (j = 0; j < nbins_x; j++) {
+			struct fd_tile *tile = &ctx->tile[t++];
+			printf("|p:%u n:%u|", tile->p, tile->n);
+		}
+		printf("\n");
 	}
+#endif
 }
 
 static void
-render_tiles(struct fd_context *ctx)
+render_tiles(struct fd_batch *batch)
 {
+	struct fd_context *ctx = batch->ctx;
 	struct fd_gmem_stateobj *gmem = &ctx->gmem;
 	int i;
 
-	ctx->emit_tile_init(ctx);
+	ctx->emit_tile_init(batch);
+
+	if (batch->restore)
+		ctx->stats.batch_restore++;
 
 	for (i = 0; i < (gmem->nbins_x * gmem->nbins_y); i++) {
 		struct fd_tile *tile = &ctx->tile[i];
@@ -208,103 +323,132 @@ render_tiles(struct fd_context *ctx)
 		DBG("bin_h=%d, yoff=%d, bin_w=%d, xoff=%d",
 			tile->bin_h, tile->yoff, tile->bin_w, tile->xoff);
 
-		ctx->emit_tile_prep(ctx, tile);
+		ctx->emit_tile_prep(batch, tile);
+
+		if (batch->restore) {
+			ctx->emit_tile_mem2gmem(batch, tile);
+		}
 
-		if (ctx->restore)
-			ctx->emit_tile_mem2gmem(ctx, tile);
+		ctx->emit_tile_renderprep(batch, tile);
 
-		ctx->emit_tile_renderprep(ctx, tile);
+		fd_hw_query_prepare_tile(batch, i, batch->gmem);
 
 		/* emit IB to drawcmds: */
-		OUT_IB(ctx->ring, ctx->draw_start, ctx->draw_end);
+		ctx->emit_ib(batch->gmem, batch->draw);
+		fd_reset_wfi(batch);
 
 		/* emit gmem2mem to transfer tile back to system memory: */
-		ctx->emit_tile_gmem2mem(ctx, tile);
+		ctx->emit_tile_gmem2mem(batch, tile);
 	}
+
+	if (ctx->emit_tile_fini)
+		ctx->emit_tile_fini(batch);
 }
 
 static void
-render_sysmem(struct fd_context *ctx)
+render_sysmem(struct fd_batch *batch)
 {
-	ctx->emit_sysmem_prep(ctx);
+	struct fd_context *ctx = batch->ctx;
+
+	ctx->emit_sysmem_prep(batch);
+
+	fd_hw_query_prepare_tile(batch, 0, batch->gmem);
 
 	/* emit IB to drawcmds: */
-	OUT_IB(ctx->ring, ctx->draw_start, ctx->draw_end);
+	ctx->emit_ib(batch->gmem, batch->draw);
+	fd_reset_wfi(batch);
 }
 
 void
-fd_gmem_render_tiles(struct pipe_context *pctx)
+fd_gmem_render_tiles(struct fd_batch *batch)
 {
-	struct fd_context *ctx = fd_context(pctx);
-	struct pipe_framebuffer_state *pfb = &ctx->framebuffer;
-	uint32_t timestamp = 0;
+	struct fd_context *ctx = batch->ctx;
+	struct pipe_framebuffer_state *pfb = &batch->framebuffer;
 	bool sysmem = false;
 
 	if (ctx->emit_sysmem_prep) {
-		if (ctx->cleared || ctx->gmem_reason || (ctx->num_draws > 5)) {
+		if (batch->cleared || batch->gmem_reason || (batch->num_draws > 5)) {
 			DBG("GMEM: cleared=%x, gmem_reason=%x, num_draws=%u",
-				ctx->cleared, ctx->gmem_reason, ctx->num_draws);
-		} else if (!(fd_mesa_debug & FD_DBG_DBYPASS)) {
+				batch->cleared, batch->gmem_reason, batch->num_draws);
+		} else if (!(fd_mesa_debug & FD_DBG_NOBYPASS)) {
 			sysmem = true;
 		}
 	}
 
-	/* mark the end of the clear/draw cmds before emitting per-tile cmds: */
-	fd_ringmarker_mark(ctx->draw_end);
+	fd_reset_wfi(batch);
+
+	ctx->stats.batch_total++;
 
 	if (sysmem) {
-		DBG("rendering sysmem (%s/%s)",
+		DBG("%p: rendering sysmem %ux%u (%s/%s)",
+			batch, pfb->width, pfb->height,
 			util_format_short_name(pipe_surface_format(pfb->cbufs[0])),
 			util_format_short_name(pipe_surface_format(pfb->zsbuf)));
-		render_sysmem(ctx);
+		fd_hw_query_prepare(batch, 1);
+		render_sysmem(batch);
+		ctx->stats.batch_sysmem++;
 	} else {
 		struct fd_gmem_stateobj *gmem = &ctx->gmem;
-		calculate_tiles(ctx);
-		DBG("rendering %dx%d tiles (%s/%s)", gmem->nbins_x, gmem->nbins_y,
+		calculate_tiles(batch);
+		DBG("%p: rendering %dx%d tiles %ux%u (%s/%s)",
+			batch, pfb->width, pfb->height, gmem->nbins_x, gmem->nbins_y,
 			util_format_short_name(pipe_surface_format(pfb->cbufs[0])),
 			util_format_short_name(pipe_surface_format(pfb->zsbuf)));
-		render_tiles(ctx);
+		fd_hw_query_prepare(batch, gmem->nbins_x * gmem->nbins_y);
+		render_tiles(batch);
+		ctx->stats.batch_gmem++;
 	}
 
-	/* GPU executes starting from tile cmds, which IB back to draw cmds: */
-	fd_ringmarker_flush(ctx->draw_end);
+	int out_fence_fd = -1;
+	fd_ringbuffer_flush2(batch->gmem, batch->in_fence_fd,
+			batch->needs_out_fence_fd ? &out_fence_fd : NULL);
 
-	/* mark start for next draw cmds: */
-	fd_ringmarker_mark(ctx->draw_start);
+	fd_fence_ref(&ctx->screen->base, &ctx->last_fence, NULL);
+	ctx->last_fence = fd_fence_create(ctx,
+			fd_ringbuffer_timestamp(batch->gmem), out_fence_fd);
+}
 
-	/* update timestamps on render targets: */
-	timestamp = fd_ringbuffer_timestamp(ctx->ring);
-	if (pfb->cbufs[0])
-		fd_resource(pfb->cbufs[0]->texture)->timestamp = timestamp;
-	if (pfb->zsbuf)
-		fd_resource(pfb->zsbuf->texture)->timestamp = timestamp;
+/* tile needs restore if it isn't completely contained within the
+ * cleared scissor:
+ */
+static bool
+skip_restore(struct pipe_scissor_state *scissor, struct fd_tile *tile)
+{
+	unsigned minx = tile->xoff;
+	unsigned maxx = tile->xoff + tile->bin_w;
+	unsigned miny = tile->yoff;
+	unsigned maxy = tile->yoff + tile->bin_h;
+	return (minx >= scissor->minx) && (maxx <= scissor->maxx) &&
+			(miny >= scissor->miny) && (maxy <= scissor->maxy);
+}
 
-	/* reset maximal bounds: */
-	ctx->max_scissor.minx = ctx->max_scissor.miny = ~0;
-	ctx->max_scissor.maxx = ctx->max_scissor.maxy = 0;
+/* When deciding whether a tile needs mem2gmem, we need to take into
+ * account the scissor rect(s) that were cleared.  To simplify we only
+ * consider the last scissor rect for each buffer, since the common
+ * case would be a single clear.
+ */
+bool
+fd_gmem_needs_restore(struct fd_batch *batch, struct fd_tile *tile,
+		uint32_t buffers)
+{
+	if (!(batch->restore & buffers))
+		return false;
 
-	/* Note that because the per-tile setup and mem2gmem/gmem2mem are emitted
-	 * after the draw/clear calls, but executed before, we need to preemptively
-	 * flag some state as dirty before the first draw/clear call.
-	 *
-	 * TODO maybe we need to mark all state as dirty to not worry about state
-	 * being clobbered by other contexts?
+	/* if buffers partially cleared, then slow-path to figure out
+	 * if this particular tile needs restoring:
 	 */
-	ctx->dirty |= FD_DIRTY_ZSA |
-			FD_DIRTY_RASTERIZER |
-			FD_DIRTY_FRAMEBUFFER |
-			FD_DIRTY_SAMPLE_MASK |
-			FD_DIRTY_VIEWPORT |
-			FD_DIRTY_CONSTBUF |
-			FD_DIRTY_PROG |
-			FD_DIRTY_SCISSOR |
-			/* probably only needed if we need to mem2gmem on the next
-			 * draw..  but not sure if there is a good way to know?
-			 */
-			FD_DIRTY_VERTTEX |
-			FD_DIRTY_FRAGTEX |
-			FD_DIRTY_BLEND;
-
-	if (fd_mesa_debug & FD_DBG_DGMEM)
-		ctx->dirty = 0xffffffff;
+	if ((buffers & FD_BUFFER_COLOR) &&
+			(batch->partial_cleared & FD_BUFFER_COLOR) &&
+			skip_restore(&batch->cleared_scissor.color, tile))
+		return false;
+	if ((buffers & FD_BUFFER_DEPTH) &&
+			(batch->partial_cleared & FD_BUFFER_DEPTH) &&
+			skip_restore(&batch->cleared_scissor.depth, tile))
+		return false;
+	if ((buffers & FD_BUFFER_STENCIL) &&
+			(batch->partial_cleared & FD_BUFFER_STENCIL) &&
+			skip_restore(&batch->cleared_scissor.stencil, tile))
+		return false;
+
+	return true;
 }