-/* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
-
/*
* Copyright (C) 2012 Rob Clark <robclark@freedesktop.org>
*
#include "util/u_string.h"
#include "util/u_memory.h"
#include "util/u_inlines.h"
-#include "util/u_format.h"
+#include "util/format/u_format.h"
#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"
* resolve.
*/
-static uint32_t bin_width(struct fd_context *ctx)
+#define BIN_DEBUG 0
+
+static uint32_t bin_width(struct fd_screen *screen)
{
- if (is_a4xx(ctx->screen))
+ if (is_a4xx(screen) || is_a5xx(screen) || is_a6xx(screen))
return 1024;
- if (is_a3xx(ctx->screen))
+ 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 bin_w, uint32_t bin_h, uint32_t gmem_align,
+ struct fd_gmem_stateobj *gmem)
{
uint32_t total = 0, i;
- for (i = 0; i < 4; i++) {
+ for (i = 0; i < MAX_RENDER_TARGETS; i++) {
if (cbuf_cpp[i]) {
- gmem->cbuf_base[i] = align(total, 0x4000);
+ gmem->cbuf_base[i] = align(total, gmem_align);
total = gmem->cbuf_base[i] + cbuf_cpp[i] * bin_w * bin_h;
}
}
if (zsbuf_cpp[0]) {
- gmem->zsbuf_base[0] = align(total, 0x4000);
+ gmem->zsbuf_base[0] = align(total, gmem_align);
total = gmem->zsbuf_base[0] + zsbuf_cpp[0] * bin_w * bin_h;
}
if (zsbuf_cpp[1]) {
- gmem->zsbuf_base[1] = align(total, 0x4000);
+ gmem->zsbuf_base[1] = align(total, gmem_align);
total = gmem->zsbuf_base[1] + zsbuf_cpp[1] * bin_w * bin_h;
}
}
static void
-calculate_tiles(struct fd_context *ctx)
+calculate_tiles(struct fd_batch *batch)
{
+ struct fd_context *ctx = batch->ctx;
+ struct fd_screen *screen = ctx->screen;
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_alignw = screen->gmem_alignw;
+ const uint32_t gmem_alignh = screen->gmem_alignh;
+ const unsigned npipes = screen->num_vsc_pipes;
+ const uint32_t gmem_size = 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 = bin_width(ctx);
- uint8_t cbuf_cpp[4] = {0}, zsbuf_cpp[2] = {0};
+ uint32_t gmem_align = 0x4000;
+ uint32_t max_width = bin_width(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 = !!(ctx->resolve & (FD_BUFFER_DEPTH | FD_BUFFER_STENCIL));
- int tile_n[ARRAY_SIZE(ctx->pipe)];
+ bool has_zs = !!(batch->gmem_reason & (FD_GMEM_DEPTH_ENABLED |
+ FD_GMEM_STENCIL_ENABLED | FD_GMEM_CLEARS_DEPTH_STENCIL));
+ int tile_n[npipes];
if (has_zs) {
struct fd_resource *rsc = fd_resource(pfb->zsbuf->texture);
- zsbuf_cpp[0] = rsc->cpp;
+ zsbuf_cpp[0] = rsc->layout.cpp;
if (rsc->stencil)
- zsbuf_cpp[1] = rsc->stencil->cpp;
+ zsbuf_cpp[1] = rsc->stencil->layout.cpp;
+ } else {
+ /* we might have a zsbuf, but it isn't used */
+ batch->restore &= ~(FD_BUFFER_DEPTH | FD_BUFFER_STENCIL);
+ batch->resolve &= ~(FD_BUFFER_DEPTH | FD_BUFFER_STENCIL);
}
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 MSAA, color buffers are super-sampled in GMEM: */
+ cbuf_cpp[i] *= pfb->samples;
}
if (!memcmp(gmem->zsbuf_cpp, zsbuf_cpp, sizeof(zsbuf_cpp)) &&
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_alignw - 1);
+ miny = scissor->miny & ~(gmem_alignh - 1);
width = scissor->maxx - minx;
height = scissor->maxy - miny;
}
- bin_w = align(width, 32);
- bin_h = align(height, 32);
+ bin_w = align(width, gmem_alignw);
+ bin_h = align(height, gmem_alignh);
/* 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_alignw);
+ }
+
+ 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);
+ }
+
+ if (is_a20x(screen) && batch->cleared) {
+ /* under normal circumstances the requirement would be 4K
+ * but the fast clear path requires an alignment of 32K
+ */
+ gmem_align = 0x8000;
}
/* then find a bin width/height that satisfies the memory
* constraints:
*/
- DBG("binning input: cbuf cpp: %d %d %d %d, zsbuf cpp: %d; %dx%d",
- cbuf_cpp[0], cbuf_cpp[1], cbuf_cpp[2], cbuf_cpp[3], zsbuf_cpp[0],
- width, height);
- while (total_size(cbuf_cpp, zsbuf_cpp, bin_w, bin_h, gmem) > gmem_size) {
+ while (total_size(cbuf_cpp, zsbuf_cpp, bin_w, bin_h, gmem_align, gmem) >
+ gmem_size) {
if (bin_w > bin_h) {
nbins_x++;
- bin_w = align(width / nbins_x, 32);
+ bin_w = align(width / nbins_x, gmem_alignw);
} else {
nbins_y++;
- bin_h = align(height / nbins_y, 32);
+ bin_h = align(height / nbins_y, gmem_alignh);
}
}
#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;
+ if (is_a20x(ctx->screen)) {
+ /* for a20x we want to minimize the number of "pipes"
+ * binning data has 3 bits for x/y (8x8) but the edges are used to
+ * cull off-screen vertices with hw binning, so we have 6x6 pipes
+ */
+ tpp_x = 6;
+ tpp_y = 6;
+ } else {
+ tpp_x = tpp_y = 1;
+ while (div_round_up(nbins_y, tpp_y) > npipes)
+ tpp_y += 2;
+ while ((div_round_up(nbins_y, tpp_y) *
+ div_round_up(nbins_x, tpp_x)) > npipes)
+ tpp_x += 1;
+ }
+
+ gmem->maxpw = tpp_x;
+ gmem->maxph = tpp_y;
/* configure pipes: */
xoff = yoff = 0;
- for (i = 0; i < ARRAY_SIZE(ctx->pipe); i++) {
- struct fd_vsc_pipe *pipe = &ctx->pipe[i];
+ for (i = 0; i < npipes; i++) {
+ struct fd_vsc_pipe *pipe = &gmem->vsc_pipe[i];
if (xoff >= nbins_x) {
xoff = 0;
xoff += tpp_x;
}
- for (; i < ARRAY_SIZE(ctx->pipe); i++) {
- struct fd_vsc_pipe *pipe = &ctx->pipe[i];
+ /* number of pipes to use for a20x */
+ gmem->num_vsc_pipes = MAX2(1, i);
+
+ for (; i < npipes; i++) {
+ struct fd_vsc_pipe *pipe = &gmem->vsc_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);
+ if (BIN_DEBUG) {
+ printf("%dx%d ... tpp=%dx%d\n", nbins_x, nbins_y, tpp_x, tpp_y);
+ for (i = 0; i < ARRAY_SIZE(gmem->vsc_pipe); i++) {
+ struct fd_vsc_pipe *pipe = &gmem->vsc_pipe[i];
+ printf("pipe[%d]: %ux%u @ %u,%u\n", i,
+ pipe->w, pipe->h, pipe->x, pipe->y);
+ }
}
-#endif
/* configure tiles: */
t = 0;
bh = MIN2(bin_h, miny + height - yoff);
for (j = 0; j < nbins_x; j++) {
- struct fd_tile *tile = &ctx->tile[t];
+ struct fd_tile *tile = &gmem->tile[t];
uint32_t p;
- assert(t < ARRAY_SIZE(ctx->tile));
+ assert(t < ARRAY_SIZE(gmem->tile));
/* pipe number: */
p = ((i / tpp_y) * div_round_up(nbins_x, tpp_x)) + (j / tpp_x);
+ assert(p < gmem->num_vsc_pipes);
/* clip bin width: */
bw = MIN2(bin_w, minx + width - xoff);
-
- tile->n = tile_n[p]++;
+ tile->n = !is_a20x(ctx->screen) ? tile_n[p]++ :
+ ((i % tpp_y + 1) << 3 | (j % tpp_x + 1));
tile->p = p;
tile->bin_w = bw;
tile->bin_h = bh;
tile->xoff = xoff;
tile->yoff = yoff;
+ if (BIN_DEBUG) {
+ printf("tile[%d]: p=%u, bin=%ux%u+%u+%u\n", t,
+ p, bw, bh, xoff, yoff);
+ }
+
t++;
xoff += bw;
yoff += bh;
}
-#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);
+ if (BIN_DEBUG) {
+ t = 0;
+ for (i = 0; i < nbins_y; i++) {
+ for (j = 0; j < nbins_x; j++) {
+ struct fd_tile *tile = &gmem->tile[t++];
+ printf("|p:%u n:%u|", tile->p, tile->n);
+ }
+ printf("\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 (ctx->restore)
+ 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];
+ struct fd_tile *tile = &gmem->tile[i];
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 (ctx->restore) {
- fd_hw_query_set_stage(ctx, ctx->ring, FD_STAGE_MEM2GMEM);
- ctx->emit_tile_mem2gmem(ctx, tile);
- fd_hw_query_set_stage(ctx, ctx->ring, FD_STAGE_NULL);
+ if (batch->restore) {
+ ctx->emit_tile_mem2gmem(batch, tile);
}
- ctx->emit_tile_renderprep(ctx, tile);
+ ctx->emit_tile_renderprep(batch, tile);
- fd_hw_query_prepare_tile(ctx, i, ctx->ring);
+ if (ctx->query_prepare_tile)
+ ctx->query_prepare_tile(batch, i, batch->gmem);
/* emit IB to drawcmds: */
- OUT_IB(ctx->ring, ctx->draw_start, ctx->draw_end);
- fd_reset_wfi(ctx);
+ if (ctx->emit_tile) {
+ ctx->emit_tile(batch, tile);
+ } else {
+ ctx->screen->emit_ib(batch->gmem, batch->draw);
+ }
+ fd_reset_wfi(batch);
/* emit gmem2mem to transfer tile back to system memory: */
- fd_hw_query_set_stage(ctx, ctx->ring, FD_STAGE_GMEM2MEM);
- ctx->emit_tile_gmem2mem(ctx, tile);
- fd_hw_query_set_stage(ctx, ctx->ring, FD_STAGE_NULL);
+ 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;
- fd_hw_query_prepare_tile(ctx, 0, ctx->ring);
+ ctx->emit_sysmem_prep(batch);
+
+ if (ctx->query_prepare_tile)
+ ctx->query_prepare_tile(batch, 0, batch->gmem);
/* emit IB to drawcmds: */
- OUT_IB(ctx->ring, ctx->draw_start, ctx->draw_end);
- fd_reset_wfi(ctx);
+ ctx->screen->emit_ib(batch->gmem, batch->draw);
+ fd_reset_wfi(batch);
+
+ if (ctx->emit_sysmem_fini)
+ ctx->emit_sysmem_fini(batch);
+}
+
+static void
+flush_ring(struct fd_batch *batch)
+{
+ uint32_t timestamp;
+ int out_fence_fd = -1;
+
+ fd_submit_flush(batch->submit, batch->in_fence_fd,
+ batch->needs_out_fence_fd ? &out_fence_fd : NULL,
+ ×tamp);
+
+ fd_fence_populate(batch->fence, timestamp, out_fence_fd);
}
void
-fd_gmem_render_tiles(struct fd_context *ctx)
+fd_gmem_render_tiles(struct fd_batch *batch)
{
- struct pipe_framebuffer_state *pfb = &ctx->framebuffer;
+ 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)) {
- DBG("GMEM: cleared=%x, gmem_reason=%x, num_draws=%u",
- ctx->cleared, ctx->gmem_reason, ctx->num_draws);
+ if (ctx->emit_sysmem_prep && !batch->nondraw) {
+ if (batch->cleared || batch->gmem_reason ||
+ ((batch->num_draws > 5) && !batch->blit) ||
+ (pfb->samples > 1)) {
+ DBG("GMEM: cleared=%x, gmem_reason=%x, num_draws=%u, samples=%u",
+ batch->cleared, batch->gmem_reason, batch->num_draws,
+ pfb->samples);
} else if (!(fd_mesa_debug & FD_DBG_NOBYPASS)) {
sysmem = true;
}
+
+ /* For ARB_framebuffer_no_attachments: */
+ if ((pfb->nr_cbufs == 0) && !pfb->zsbuf) {
+ sysmem = true;
+ }
}
- /* close out the draw cmds by making sure any active queries are
- * paused:
- */
- fd_hw_query_set_stage(ctx, ctx->ring, FD_STAGE_NULL);
+ if (fd_mesa_debug & FD_DBG_NOGMEM)
+ sysmem = true;
- /* mark the end of the clear/draw cmds before emitting per-tile cmds: */
- fd_ringmarker_mark(ctx->draw_end);
- fd_ringmarker_mark(ctx->binning_end);
+ /* Layered rendering always needs bypass. */
+ for (unsigned i = 0; i < pfb->nr_cbufs; i++) {
+ struct pipe_surface *psurf = pfb->cbufs[i];
+ if (!psurf)
+ continue;
+ if (psurf->u.tex.first_layer < psurf->u.tex.last_layer)
+ sysmem = true;
+ }
+
+ /* Tessellation doesn't seem to support tiled rendering so fall back to
+ * bypass.
+ */
+ if (batch->tessellation) {
+ debug_assert(ctx->emit_sysmem_prep);
+ sysmem = true;
+ }
- fd_reset_wfi(ctx);
+ fd_reset_wfi(batch);
ctx->stats.batch_total++;
- if (sysmem) {
- DBG("rendering sysmem (%s/%s)",
+ if (batch->nondraw) {
+ DBG("%p: rendering non-draw", batch);
+ ctx->stats.batch_nondraw++;
+ } else if (sysmem) {
+ DBG("%p: rendering sysmem %ux%u (%s/%s), num_draws=%u",
+ batch, pfb->width, pfb->height,
util_format_short_name(pipe_surface_format(pfb->cbufs[0])),
- util_format_short_name(pipe_surface_format(pfb->zsbuf)));
- fd_hw_query_prepare(ctx, 1);
- render_sysmem(ctx);
+ util_format_short_name(pipe_surface_format(pfb->zsbuf)),
+ batch->num_draws);
+ if (ctx->query_prepare)
+ ctx->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)));
- fd_hw_query_prepare(ctx, gmem->nbins_x * gmem->nbins_y);
- render_tiles(ctx);
+ if (ctx->query_prepare)
+ ctx->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);
-
- /* mark start for next draw/binning cmds: */
- fd_ringmarker_mark(ctx->draw_start);
- fd_ringmarker_mark(ctx->binning_start);
-
- fd_reset_wfi(ctx);
-
- /* reset maximal bounds: */
- ctx->max_scissor.minx = ctx->max_scissor.miny = ~0;
- ctx->max_scissor.maxx = ctx->max_scissor.maxy = 0;
-
- ctx->dirty = ~0;
-}
-
-/* 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);
+ flush_ring(batch);
}
/* When deciding whether a tile needs mem2gmem, we need to take into
* case would be a single clear.
*/
bool
-fd_gmem_needs_restore(struct fd_context *ctx, struct fd_tile *tile,
+fd_gmem_needs_restore(struct fd_batch *batch, const struct fd_tile *tile,
uint32_t buffers)
{
- if (!(ctx->restore & buffers))
- return false;
-
- /* if buffers partially cleared, then slow-path to figure out
- * if this particular tile needs restoring:
- */
- if ((buffers & FD_BUFFER_COLOR) &&
- (ctx->partial_cleared & FD_BUFFER_COLOR) &&
- skip_restore(&ctx->cleared_scissor.color, tile))
- return false;
- if ((buffers & FD_BUFFER_DEPTH) &&
- (ctx->partial_cleared & FD_BUFFER_DEPTH) &&
- skip_restore(&ctx->cleared_scissor.depth, tile))
- return false;
- if ((buffers & FD_BUFFER_STENCIL) &&
- (ctx->partial_cleared & FD_BUFFER_STENCIL) &&
- skip_restore(&ctx->cleared_scissor.stencil, tile))
+ if (!(batch->restore & buffers))
return false;
return true;