#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"
static uint32_t bin_width(struct fd_screen *screen)
{
- if (is_a4xx(screen))
+ if (is_a4xx(screen) || is_a5xx(screen))
return 1024;
if (is_a3xx(screen))
return 992;
struct fd_gmem_stateobj *gmem = &ctx->gmem;
struct pipe_scissor_state *scissor = &batch->max_scissor;
struct pipe_framebuffer_state *pfb = &batch->framebuffer;
- uint32_t gmem_size = ctx->screen->gmemsize_bytes;
+ const uint32_t gmem_alignw = ctx->screen->gmem_alignw;
+ const uint32_t gmem_alignh = ctx->screen->gmem_alignh;
+ const unsigned npipes = ctx->screen->num_vsc_pipes;
+ 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 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)];
+ int tile_n[npipes];
if (has_zs) {
struct fd_resource *rsc = fd_resource(pfb->zsbuf->texture);
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) {
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, 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);
}
}
div_round_up(nbins_x, tpp_x)) > 8)
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 = &ctx->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];
+ for (; i < npipes; i++) {
+ struct fd_vsc_pipe *pipe = &ctx->vsc_pipe[i];
pipe->x = pipe->y = pipe->w = pipe->h = 0;
}
ctx->emit_tile_prep(batch, tile);
if (batch->restore) {
- fd_hw_query_set_stage(ctx, batch->gmem, FD_STAGE_MEM2GMEM);
ctx->emit_tile_mem2gmem(batch, tile);
- fd_hw_query_set_stage(ctx, batch->gmem, FD_STAGE_NULL);
}
ctx->emit_tile_renderprep(batch, tile);
- fd_hw_query_prepare_tile(ctx, i, batch->gmem);
+ if (ctx->query_prepare_tile)
+ ctx->query_prepare_tile(batch, i, batch->gmem);
/* emit IB to drawcmds: */
ctx->emit_ib(batch->gmem, batch->draw);
- fd_reset_wfi(ctx);
+ fd_reset_wfi(batch);
/* emit gmem2mem to transfer tile back to system memory: */
- fd_hw_query_set_stage(ctx, batch->gmem, FD_STAGE_GMEM2MEM);
ctx->emit_tile_gmem2mem(batch, tile);
- fd_hw_query_set_stage(ctx, batch->gmem, FD_STAGE_NULL);
}
+
+ if (ctx->emit_tile_fini)
+ ctx->emit_tile_fini(batch);
}
static void
ctx->emit_sysmem_prep(batch);
- fd_hw_query_prepare_tile(ctx, 0, batch->gmem);
+ if (ctx->query_prepare_tile)
+ ctx->query_prepare_tile(batch, 0, batch->gmem);
/* emit IB to drawcmds: */
ctx->emit_ib(batch->gmem, batch->draw);
- fd_reset_wfi(ctx);
+ fd_reset_wfi(batch);
+
+ if (ctx->emit_sysmem_fini)
+ ctx->emit_sysmem_fini(batch);
+}
+
+static void
+flush_ring(struct fd_batch *batch)
+{
+ /* for compute/blit batch, there is no batch->gmem, only batch->draw: */
+ struct fd_ringbuffer *ring = batch->nondraw ? batch->draw : batch->gmem;
+ uint32_t timestamp;
+ int out_fence_fd = -1;
+
+ fd_ringbuffer_flush2(ring, batch->in_fence_fd,
+ batch->needs_out_fence_fd ? &out_fence_fd : NULL);
+
+ timestamp = fd_ringbuffer_timestamp(ring);
+ fd_fence_populate(batch->fence, timestamp, out_fence_fd);
}
void
struct pipe_framebuffer_state *pfb = &batch->framebuffer;
bool sysmem = false;
- if (ctx->emit_sysmem_prep) {
- if (batch->cleared || batch->gmem_reason || (batch->num_draws > 5)) {
+ if (ctx->emit_sysmem_prep && !batch->nondraw) {
+ if (batch->cleared || batch->gmem_reason ||
+ ((batch->num_draws > 5) && !batch->blit)) {
DBG("GMEM: cleared=%x, gmem_reason=%x, num_draws=%u",
batch->cleared, batch->gmem_reason, batch->num_draws);
} else if (!(fd_mesa_debug & FD_DBG_NOBYPASS)) {
sysmem = true;
}
- }
- /* close out the draw cmds by making sure any active queries are
- * paused:
- */
- fd_hw_query_set_stage(ctx, batch->draw, FD_STAGE_NULL);
+ /* For ARB_framebuffer_no_attachments: */
+ if ((pfb->nr_cbufs == 0) && !pfb->zsbuf) {
+ 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)",
+ 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);
+ 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(batch);
- DBG("rendering %dx%d tiles (%s/%s)", gmem->nbins_x, gmem->nbins_y,
+ 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);
+ if (ctx->query_prepare)
+ ctx->query_prepare(batch, gmem->nbins_x * gmem->nbins_y);
render_tiles(batch);
ctx->stats.batch_gmem++;
}
- fd_ringbuffer_flush(batch->gmem);
+ flush_ring(batch);
+}
- fd_reset_wfi(ctx);
+/* special case for when we need to create a fence but have no rendering
+ * to flush.. just emit a no-op string-marker packet.
+ */
+void
+fd_gmem_render_noop(struct fd_batch *batch)
+{
+ struct fd_context *ctx = batch->ctx;
+ struct pipe_context *pctx = &ctx->base;
- ctx->dirty = ~0;
+ pctx->emit_string_marker(pctx, "noop", 4);
+ /* emit IB to drawcmds (which contain the string marker): */
+ ctx->emit_ib(batch->gmem, batch->draw);
+ flush_ring(batch);
}
/* tile needs restore if it isn't completely contained within the