#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"
* resolve.
*/
+#define BIN_DEBUG 0
+
static uint32_t bin_width(struct fd_screen *screen)
{
if (is_a4xx(screen) || is_a5xx(screen) || is_a6xx(screen))
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 < 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;
}
uint32_t minx, miny, width, height;
uint32_t nbins_x = 1, nbins_y = 1;
uint32_t bin_w, bin_h;
+ 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 = !!((batch->resolve | batch->restore) &
- (FD_BUFFER_DEPTH | FD_BUFFER_STENCIL));
+ 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])
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:
*/
- 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, gmem_alignw);
tpp_y = 6;
} else {
tpp_x = tpp_y = 1;
- while (div_round_up(nbins_y, tpp_y) > screen->num_vsc_pipes)
+ 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)) > screen->num_vsc_pipes)
+ div_round_up(nbins_x, tpp_x)) > npipes)
tpp_x += 1;
}
/* configure pipes: */
xoff = yoff = 0;
for (i = 0; i < npipes; i++) {
- struct fd_vsc_pipe *pipe = &ctx->vsc_pipe[i];
+ struct fd_vsc_pipe *pipe = &gmem->vsc_pipe[i];
if (xoff >= nbins_x) {
xoff = 0;
gmem->num_vsc_pipes = MAX2(1, i);
for (; i < npipes; i++) {
- struct fd_vsc_pipe *pipe = &ctx->vsc_pipe[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);
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
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->query_prepare_tile(batch, i, batch->gmem);
/* emit IB to drawcmds: */
- ctx->emit_ib(batch->gmem, batch->draw);
+ 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: */
ctx->query_prepare_tile(batch, 0, batch->gmem);
/* emit IB to drawcmds: */
- ctx->emit_ib(batch->gmem, batch->draw);
+ ctx->screen->emit_ib(batch->gmem, batch->draw);
fd_reset_wfi(batch);
if (ctx->emit_sysmem_fini)
}
}
+ if (fd_mesa_debug & FD_DBG_NOGMEM)
+ sysmem = true;
+
+ /* 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(batch);
ctx->stats.batch_total++;
DBG("%p: rendering non-draw", batch);
ctx->stats.batch_nondraw++;
} else if (sysmem) {
- DBG("%p: rendering sysmem %ux%u (%s/%s)",
+ 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)));
+ util_format_short_name(pipe_surface_format(pfb->zsbuf)),
+ batch->num_draws);
if (ctx->query_prepare)
ctx->query_prepare(batch, 1);
render_sysmem(batch);
* case would be a single clear.
*/
bool
-fd_gmem_needs_restore(struct fd_batch *batch, struct fd_tile *tile,
+fd_gmem_needs_restore(struct fd_batch *batch, const struct fd_tile *tile,
uint32_t buffers)
{
if (!(batch->restore & buffers))