• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
2 
3 /*
4  * Copyright (C) 2012 Rob Clark <robclark@freedesktop.org>
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the "Software"),
8  * to deal in the Software without restriction, including without limitation
9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10  * and/or sell copies of the Software, and to permit persons to whom the
11  * Software is furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice (including the next
14  * paragraph) shall be included in all copies or substantial portions of the
15  * Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23  * SOFTWARE.
24  *
25  * Authors:
26  *    Rob Clark <robclark@freedesktop.org>
27  */
28 
29 #include "pipe/p_state.h"
30 #include "util/u_string.h"
31 #include "util/u_memory.h"
32 #include "util/u_inlines.h"
33 #include "util/u_format.h"
34 
35 #include "freedreno_gmem.h"
36 #include "freedreno_context.h"
37 #include "freedreno_fence.h"
38 #include "freedreno_resource.h"
39 #include "freedreno_query_hw.h"
40 #include "freedreno_util.h"
41 
42 /*
43  * GMEM is the small (ie. 256KiB for a200, 512KiB for a220, etc) tile buffer
44  * inside the GPU.  All rendering happens to GMEM.  Larger render targets
45  * are split into tiles that are small enough for the color (and depth and/or
46  * stencil, if enabled) buffers to fit within GMEM.  Before rendering a tile,
47  * if there was not a clear invalidating the previous tile contents, we need
48  * to restore the previous tiles contents (system mem -> GMEM), and after all
49  * the draw calls, before moving to the next tile, we need to save the tile
50  * contents (GMEM -> system mem).
51  *
52  * The code in this file handles dealing with GMEM and tiling.
53  *
54  * The structure of the ringbuffer ends up being:
55  *
56  *     +--<---<-- IB ---<---+---<---+---<---<---<--+
57  *     |                    |       |              |
58  *     v                    ^       ^              ^
59  *   ------------------------------------------------------
60  *     | clear/draw cmds | Tile0 | Tile1 | .... | TileN |
61  *   ------------------------------------------------------
62  *                       ^
63  *                       |
64  *                       address submitted in issueibcmds
65  *
66  * Where the per-tile section handles scissor setup, mem2gmem restore (if
67  * needed), IB to draw cmds earlier in the ringbuffer, and then gmem2mem
68  * resolve.
69  */
70 
bin_width(struct fd_screen * screen)71 static uint32_t bin_width(struct fd_screen *screen)
72 {
73 	if (is_a4xx(screen) || is_a5xx(screen))
74 		return 1024;
75 	if (is_a3xx(screen))
76 		return 992;
77 	return 512;
78 }
79 
80 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)81 total_size(uint8_t cbuf_cpp[], uint8_t zsbuf_cpp[2],
82 		   uint32_t bin_w, uint32_t bin_h, struct fd_gmem_stateobj *gmem)
83 {
84 	uint32_t total = 0, i;
85 
86 	for (i = 0; i < MAX_RENDER_TARGETS; i++) {
87 		if (cbuf_cpp[i]) {
88 			gmem->cbuf_base[i] = align(total, 0x4000);
89 			total = gmem->cbuf_base[i] + cbuf_cpp[i] * bin_w * bin_h;
90 		}
91 	}
92 
93 	if (zsbuf_cpp[0]) {
94 		gmem->zsbuf_base[0] = align(total, 0x4000);
95 		total = gmem->zsbuf_base[0] + zsbuf_cpp[0] * bin_w * bin_h;
96 	}
97 
98 	if (zsbuf_cpp[1]) {
99 		gmem->zsbuf_base[1] = align(total, 0x4000);
100 		total = gmem->zsbuf_base[1] + zsbuf_cpp[1] * bin_w * bin_h;
101 	}
102 
103 	return total;
104 }
105 
106 static void
calculate_tiles(struct fd_batch * batch)107 calculate_tiles(struct fd_batch *batch)
108 {
109 	struct fd_context *ctx = batch->ctx;
110 	struct fd_gmem_stateobj *gmem = &ctx->gmem;
111 	struct pipe_scissor_state *scissor = &batch->max_scissor;
112 	struct pipe_framebuffer_state *pfb = &batch->framebuffer;
113 	const uint32_t gmem_alignw = ctx->screen->gmem_alignw;
114 	const uint32_t gmem_alignh = ctx->screen->gmem_alignh;
115 	const uint32_t gmem_size = ctx->screen->gmemsize_bytes;
116 	uint32_t minx, miny, width, height;
117 	uint32_t nbins_x = 1, nbins_y = 1;
118 	uint32_t bin_w, bin_h;
119 	uint32_t max_width = bin_width(ctx->screen);
120 	uint8_t cbuf_cpp[MAX_RENDER_TARGETS] = {0}, zsbuf_cpp[2] = {0};
121 	uint32_t i, j, t, xoff, yoff;
122 	uint32_t tpp_x, tpp_y;
123 	bool has_zs = !!(batch->resolve & (FD_BUFFER_DEPTH | FD_BUFFER_STENCIL));
124 	int tile_n[ARRAY_SIZE(ctx->pipe)];
125 
126 	if (has_zs) {
127 		struct fd_resource *rsc = fd_resource(pfb->zsbuf->texture);
128 		zsbuf_cpp[0] = rsc->cpp;
129 		if (rsc->stencil)
130 			zsbuf_cpp[1] = rsc->stencil->cpp;
131 	}
132 	for (i = 0; i < pfb->nr_cbufs; i++) {
133 		if (pfb->cbufs[i])
134 			cbuf_cpp[i] = util_format_get_blocksize(pfb->cbufs[i]->format);
135 		else
136 			cbuf_cpp[i] = 4;
137 	}
138 
139 	if (!memcmp(gmem->zsbuf_cpp, zsbuf_cpp, sizeof(zsbuf_cpp)) &&
140 		!memcmp(gmem->cbuf_cpp, cbuf_cpp, sizeof(cbuf_cpp)) &&
141 		!memcmp(&gmem->scissor, scissor, sizeof(gmem->scissor))) {
142 		/* everything is up-to-date */
143 		return;
144 	}
145 
146 	if (fd_mesa_debug & FD_DBG_NOSCIS) {
147 		minx = 0;
148 		miny = 0;
149 		width = pfb->width;
150 		height = pfb->height;
151 	} else {
152 		/* round down to multiple of alignment: */
153 		minx = scissor->minx & ~(gmem_alignw - 1);
154 		miny = scissor->miny & ~(gmem_alignh - 1);
155 		width = scissor->maxx - minx;
156 		height = scissor->maxy - miny;
157 	}
158 
159 	bin_w = align(width, gmem_alignw);
160 	bin_h = align(height, gmem_alignh);
161 
162 	/* first, find a bin width that satisfies the maximum width
163 	 * restrictions:
164 	 */
165 	while (bin_w > max_width) {
166 		nbins_x++;
167 		bin_w = align(width / nbins_x, gmem_alignw);
168 	}
169 
170 	if (fd_mesa_debug & FD_DBG_MSGS) {
171 		debug_printf("binning input: cbuf cpp:");
172 		for (i = 0; i < pfb->nr_cbufs; i++)
173 			debug_printf(" %d", cbuf_cpp[i]);
174 		debug_printf(", zsbuf cpp: %d; %dx%d\n",
175 				zsbuf_cpp[0], width, height);
176 	}
177 
178 	/* then find a bin width/height that satisfies the memory
179 	 * constraints:
180 	 */
181 	while (total_size(cbuf_cpp, zsbuf_cpp, bin_w, bin_h, gmem) > gmem_size) {
182 		if (bin_w > bin_h) {
183 			nbins_x++;
184 			bin_w = align(width / nbins_x, gmem_alignw);
185 		} else {
186 			nbins_y++;
187 			bin_h = align(height / nbins_y, gmem_alignh);
188 		}
189 	}
190 
191 	DBG("using %d bins of size %dx%d", nbins_x*nbins_y, bin_w, bin_h);
192 
193 	gmem->scissor = *scissor;
194 	memcpy(gmem->cbuf_cpp, cbuf_cpp, sizeof(cbuf_cpp));
195 	memcpy(gmem->zsbuf_cpp, zsbuf_cpp, sizeof(zsbuf_cpp));
196 	gmem->bin_h = bin_h;
197 	gmem->bin_w = bin_w;
198 	gmem->nbins_x = nbins_x;
199 	gmem->nbins_y = nbins_y;
200 	gmem->minx = minx;
201 	gmem->miny = miny;
202 	gmem->width = width;
203 	gmem->height = height;
204 
205 	/*
206 	 * Assign tiles and pipes:
207 	 *
208 	 * At some point it might be worth playing with different
209 	 * strategies and seeing if that makes much impact on
210 	 * performance.
211 	 */
212 
213 #define div_round_up(v, a)  (((v) + (a) - 1) / (a))
214 	/* figure out number of tiles per pipe: */
215 	tpp_x = tpp_y = 1;
216 	while (div_round_up(nbins_y, tpp_y) > 8)
217 		tpp_y += 2;
218 	while ((div_round_up(nbins_y, tpp_y) *
219 			div_round_up(nbins_x, tpp_x)) > 8)
220 		tpp_x += 1;
221 
222 	/* configure pipes: */
223 	xoff = yoff = 0;
224 	for (i = 0; i < ARRAY_SIZE(ctx->pipe); i++) {
225 		struct fd_vsc_pipe *pipe = &ctx->pipe[i];
226 
227 		if (xoff >= nbins_x) {
228 			xoff = 0;
229 			yoff += tpp_y;
230 		}
231 
232 		if (yoff >= nbins_y) {
233 			break;
234 		}
235 
236 		pipe->x = xoff;
237 		pipe->y = yoff;
238 		pipe->w = MIN2(tpp_x, nbins_x - xoff);
239 		pipe->h = MIN2(tpp_y, nbins_y - yoff);
240 
241 		xoff += tpp_x;
242 	}
243 
244 	for (; i < ARRAY_SIZE(ctx->pipe); i++) {
245 		struct fd_vsc_pipe *pipe = &ctx->pipe[i];
246 		pipe->x = pipe->y = pipe->w = pipe->h = 0;
247 	}
248 
249 #if 0 /* debug */
250 	printf("%dx%d ... tpp=%dx%d\n", nbins_x, nbins_y, tpp_x, tpp_y);
251 	for (i = 0; i < 8; i++) {
252 		struct fd_vsc_pipe *pipe = &ctx->pipe[i];
253 		printf("pipe[%d]: %ux%u @ %u,%u\n", i,
254 				pipe->w, pipe->h, pipe->x, pipe->y);
255 	}
256 #endif
257 
258 	/* configure tiles: */
259 	t = 0;
260 	yoff = miny;
261 	memset(tile_n, 0, sizeof(tile_n));
262 	for (i = 0; i < nbins_y; i++) {
263 		uint32_t bw, bh;
264 
265 		xoff = minx;
266 
267 		/* clip bin height: */
268 		bh = MIN2(bin_h, miny + height - yoff);
269 
270 		for (j = 0; j < nbins_x; j++) {
271 			struct fd_tile *tile = &ctx->tile[t];
272 			uint32_t p;
273 
274 			assert(t < ARRAY_SIZE(ctx->tile));
275 
276 			/* pipe number: */
277 			p = ((i / tpp_y) * div_round_up(nbins_x, tpp_x)) + (j / tpp_x);
278 
279 			/* clip bin width: */
280 			bw = MIN2(bin_w, minx + width - xoff);
281 
282 			tile->n = tile_n[p]++;
283 			tile->p = p;
284 			tile->bin_w = bw;
285 			tile->bin_h = bh;
286 			tile->xoff = xoff;
287 			tile->yoff = yoff;
288 
289 			t++;
290 
291 			xoff += bw;
292 		}
293 
294 		yoff += bh;
295 	}
296 
297 #if 0 /* debug */
298 	t = 0;
299 	for (i = 0; i < nbins_y; i++) {
300 		for (j = 0; j < nbins_x; j++) {
301 			struct fd_tile *tile = &ctx->tile[t++];
302 			printf("|p:%u n:%u|", tile->p, tile->n);
303 		}
304 		printf("\n");
305 	}
306 #endif
307 }
308 
309 static void
render_tiles(struct fd_batch * batch)310 render_tiles(struct fd_batch *batch)
311 {
312 	struct fd_context *ctx = batch->ctx;
313 	struct fd_gmem_stateobj *gmem = &ctx->gmem;
314 	int i;
315 
316 	ctx->emit_tile_init(batch);
317 
318 	if (batch->restore)
319 		ctx->stats.batch_restore++;
320 
321 	for (i = 0; i < (gmem->nbins_x * gmem->nbins_y); i++) {
322 		struct fd_tile *tile = &ctx->tile[i];
323 
324 		DBG("bin_h=%d, yoff=%d, bin_w=%d, xoff=%d",
325 			tile->bin_h, tile->yoff, tile->bin_w, tile->xoff);
326 
327 		ctx->emit_tile_prep(batch, tile);
328 
329 		if (batch->restore) {
330 			ctx->emit_tile_mem2gmem(batch, tile);
331 		}
332 
333 		ctx->emit_tile_renderprep(batch, tile);
334 
335 		fd_hw_query_prepare_tile(batch, i, batch->gmem);
336 
337 		/* emit IB to drawcmds: */
338 		ctx->emit_ib(batch->gmem, batch->draw);
339 		fd_reset_wfi(batch);
340 
341 		/* emit gmem2mem to transfer tile back to system memory: */
342 		ctx->emit_tile_gmem2mem(batch, tile);
343 	}
344 
345 	if (ctx->emit_tile_fini)
346 		ctx->emit_tile_fini(batch);
347 }
348 
349 static void
render_sysmem(struct fd_batch * batch)350 render_sysmem(struct fd_batch *batch)
351 {
352 	struct fd_context *ctx = batch->ctx;
353 
354 	ctx->emit_sysmem_prep(batch);
355 
356 	fd_hw_query_prepare_tile(batch, 0, batch->gmem);
357 
358 	/* emit IB to drawcmds: */
359 	ctx->emit_ib(batch->gmem, batch->draw);
360 	fd_reset_wfi(batch);
361 
362 	if (ctx->emit_sysmem_fini)
363 		ctx->emit_sysmem_fini(batch);
364 }
365 
366 static void
flush_ring(struct fd_batch * batch)367 flush_ring(struct fd_batch *batch)
368 {
369 	struct fd_context *ctx = batch->ctx;
370 	int out_fence_fd = -1;
371 
372 	fd_ringbuffer_flush2(batch->gmem, batch->in_fence_fd,
373 			batch->needs_out_fence_fd ? &out_fence_fd : NULL);
374 
375 	fd_fence_ref(&ctx->screen->base, &ctx->last_fence, NULL);
376 	ctx->last_fence = fd_fence_create(ctx,
377 			fd_ringbuffer_timestamp(batch->gmem), out_fence_fd);
378 }
379 
380 void
fd_gmem_render_tiles(struct fd_batch * batch)381 fd_gmem_render_tiles(struct fd_batch *batch)
382 {
383 	struct fd_context *ctx = batch->ctx;
384 	struct pipe_framebuffer_state *pfb = &batch->framebuffer;
385 	bool sysmem = false;
386 
387 	if (ctx->emit_sysmem_prep) {
388 		if (batch->cleared || batch->gmem_reason || (batch->num_draws > 5)) {
389 			DBG("GMEM: cleared=%x, gmem_reason=%x, num_draws=%u",
390 				batch->cleared, batch->gmem_reason, batch->num_draws);
391 		} else if (!(fd_mesa_debug & FD_DBG_NOBYPASS)) {
392 			sysmem = true;
393 		}
394 	}
395 
396 	fd_reset_wfi(batch);
397 
398 	ctx->stats.batch_total++;
399 
400 	if (sysmem) {
401 		DBG("%p: rendering sysmem %ux%u (%s/%s)",
402 			batch, pfb->width, pfb->height,
403 			util_format_short_name(pipe_surface_format(pfb->cbufs[0])),
404 			util_format_short_name(pipe_surface_format(pfb->zsbuf)));
405 		fd_hw_query_prepare(batch, 1);
406 		render_sysmem(batch);
407 		ctx->stats.batch_sysmem++;
408 	} else {
409 		struct fd_gmem_stateobj *gmem = &ctx->gmem;
410 		calculate_tiles(batch);
411 		DBG("%p: rendering %dx%d tiles %ux%u (%s/%s)",
412 			batch, pfb->width, pfb->height, gmem->nbins_x, gmem->nbins_y,
413 			util_format_short_name(pipe_surface_format(pfb->cbufs[0])),
414 			util_format_short_name(pipe_surface_format(pfb->zsbuf)));
415 		fd_hw_query_prepare(batch, gmem->nbins_x * gmem->nbins_y);
416 		render_tiles(batch);
417 		ctx->stats.batch_gmem++;
418 	}
419 
420 	flush_ring(batch);
421 }
422 
423 /* special case for when we need to create a fence but have no rendering
424  * to flush.. just emit a no-op string-marker packet.
425  */
426 void
fd_gmem_render_noop(struct fd_batch * batch)427 fd_gmem_render_noop(struct fd_batch *batch)
428 {
429 	struct fd_context *ctx = batch->ctx;
430 	struct pipe_context *pctx = &ctx->base;
431 
432 	pctx->emit_string_marker(pctx, "noop", 4);
433 	/* emit IB to drawcmds (which contain the string marker): */
434 	ctx->emit_ib(batch->gmem, batch->draw);
435 	flush_ring(batch);
436 }
437 
438 /* tile needs restore if it isn't completely contained within the
439  * cleared scissor:
440  */
441 static bool
skip_restore(struct pipe_scissor_state * scissor,struct fd_tile * tile)442 skip_restore(struct pipe_scissor_state *scissor, struct fd_tile *tile)
443 {
444 	unsigned minx = tile->xoff;
445 	unsigned maxx = tile->xoff + tile->bin_w;
446 	unsigned miny = tile->yoff;
447 	unsigned maxy = tile->yoff + tile->bin_h;
448 	return (minx >= scissor->minx) && (maxx <= scissor->maxx) &&
449 			(miny >= scissor->miny) && (maxy <= scissor->maxy);
450 }
451 
452 /* When deciding whether a tile needs mem2gmem, we need to take into
453  * account the scissor rect(s) that were cleared.  To simplify we only
454  * consider the last scissor rect for each buffer, since the common
455  * case would be a single clear.
456  */
457 bool
fd_gmem_needs_restore(struct fd_batch * batch,struct fd_tile * tile,uint32_t buffers)458 fd_gmem_needs_restore(struct fd_batch *batch, struct fd_tile *tile,
459 		uint32_t buffers)
460 {
461 	if (!(batch->restore & buffers))
462 		return false;
463 
464 	/* if buffers partially cleared, then slow-path to figure out
465 	 * if this particular tile needs restoring:
466 	 */
467 	if ((buffers & FD_BUFFER_COLOR) &&
468 			(batch->partial_cleared & FD_BUFFER_COLOR) &&
469 			skip_restore(&batch->cleared_scissor.color, tile))
470 		return false;
471 	if ((buffers & FD_BUFFER_DEPTH) &&
472 			(batch->partial_cleared & FD_BUFFER_DEPTH) &&
473 			skip_restore(&batch->cleared_scissor.depth, tile))
474 		return false;
475 	if ((buffers & FD_BUFFER_STENCIL) &&
476 			(batch->partial_cleared & FD_BUFFER_STENCIL) &&
477 			skip_restore(&batch->cleared_scissor.stencil, tile))
478 		return false;
479 
480 	return true;
481 }
482