#include <xf86drm.h>
#include <err.h>
-#include <stdio.h>
#include "pipe/p_defines.h"
+#include "util/ralloc.h"
#include "util/u_inlines.h"
#include "util/u_memory.h"
#include "util/u_blitter.h"
+#include "util/u_upload_mgr.h"
#include "indices/u_primconvert.h"
#include "pipe/p_screen.h"
#include "vc4_context.h"
#include "vc4_resource.h"
-static void
-dump_fbo(struct vc4_context *vc4, struct vc4_bo *fbo)
+void
+vc4_flush(struct pipe_context *pctx)
{
-#ifndef USE_VC4_SIMULATOR
- uint32_t *map = vc4_bo_map(fbo);
- uint32_t width = vc4->framebuffer.width;
- uint32_t height = vc4->framebuffer.height;
- uint32_t chunk_w = width / 79;
- uint32_t chunk_h = height / 40;
- uint32_t found_colors[10];
- uint32_t num_found_colors = 0;
-
- for (int by = 0; by < height; by += chunk_h) {
- for (int bx = 0; bx < width; bx += chunk_w) {
- bool on = false, black = false;
-
- for (int y = by; y < MIN2(height, by + chunk_h); y++) {
- for (int x = bx; x < MIN2(width, bx + chunk_w); x++) {
- uint32_t pix = map[y * width + x];
- on |= pix != 0;
- black |= pix == 0xff000000;
-
- int i;
- for (i = 0; i < num_found_colors; i++) {
- if (pix == found_colors[i])
- break;
- }
- if (i == num_found_colors &&
- num_found_colors < Elements(found_colors))
- found_colors[num_found_colors++] = pix;
- }
- }
- if (black)
- fprintf(stderr, "O");
- else if (on)
- fprintf(stderr, "X");
- else
- fprintf(stderr, ".");
+ struct vc4_context *vc4 = vc4_context(pctx);
+ struct pipe_surface *cbuf = vc4->framebuffer.cbufs[0];
+ struct pipe_surface *zsbuf = vc4->framebuffer.zsbuf;
+
+ if (!vc4->needs_flush)
+ return;
+
+ /* The RCL setup would choke if the draw bounds cause no drawing, so
+ * just drop the drawing if that's the case.
+ */
+ if (vc4->draw_max_x <= vc4->draw_min_x ||
+ vc4->draw_max_y <= vc4->draw_min_y) {
+ vc4_job_reset(vc4);
+ return;
+ }
+
+ /* Increment the semaphore indicating that binning is done and
+ * unblocking the render thread. Note that this doesn't act until the
+ * FLUSH completes.
+ */
+ cl_ensure_space(&vc4->bcl, 8);
+ struct vc4_cl_out *bcl = cl_start(&vc4->bcl);
+ cl_u8(&bcl, VC4_PACKET_INCREMENT_SEMAPHORE);
+ /* The FLUSH caps all of our bin lists with a VC4_PACKET_RETURN. */
+ cl_u8(&bcl, VC4_PACKET_FLUSH);
+ cl_end(&vc4->bcl, bcl);
+
+ if (cbuf && (vc4->resolve & PIPE_CLEAR_COLOR0)) {
+ pipe_surface_reference(&vc4->color_write,
+ cbuf->texture->nr_samples > 1 ?
+ NULL : cbuf);
+ pipe_surface_reference(&vc4->msaa_color_write,
+ cbuf->texture->nr_samples > 1 ?
+ cbuf : NULL);
+
+ if (!(vc4->cleared & PIPE_CLEAR_COLOR0)) {
+ pipe_surface_reference(&vc4->color_read, cbuf);
+ } else {
+ pipe_surface_reference(&vc4->color_read, NULL);
}
- fprintf(stderr, "\n");
+
+ } else {
+ pipe_surface_reference(&vc4->color_write, NULL);
+ pipe_surface_reference(&vc4->color_read, NULL);
+ pipe_surface_reference(&vc4->msaa_color_write, NULL);
}
- for (int i = 0; i < num_found_colors; i++) {
- fprintf(stderr, "color %d: 0x%08x\n", i, found_colors[i]);
+ if (vc4->framebuffer.zsbuf &&
+ (vc4->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
+ pipe_surface_reference(&vc4->zs_write,
+ zsbuf->texture->nr_samples > 1 ?
+ NULL : zsbuf);
+ pipe_surface_reference(&vc4->msaa_zs_write,
+ zsbuf->texture->nr_samples > 1 ?
+ zsbuf : NULL);
+
+ if (!(vc4->cleared & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
+ pipe_surface_reference(&vc4->zs_read, zsbuf);
+ } else {
+ pipe_surface_reference(&vc4->zs_read, NULL);
+ }
+ } else {
+ pipe_surface_reference(&vc4->zs_write, NULL);
+ pipe_surface_reference(&vc4->zs_read, NULL);
+ pipe_surface_reference(&vc4->msaa_zs_write, NULL);
}
-#endif
+
+ vc4_job_submit(vc4);
}
-void
-vc4_flush(struct pipe_context *pctx)
+static void
+vc4_pipe_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence,
+ unsigned flags)
+{
+ struct vc4_context *vc4 = vc4_context(pctx);
+
+ vc4_flush(pctx);
+
+ if (fence) {
+ struct pipe_screen *screen = pctx->screen;
+ struct vc4_fence *f = vc4_fence_create(vc4->screen,
+ vc4->last_emit_seqno);
+ screen->fence_reference(screen, fence, NULL);
+ *fence = (struct pipe_fence_handle *)f;
+ }
+}
+
+/**
+ * Flushes the current command lists if they reference the given BO.
+ *
+ * This helps avoid flushing the command buffers when unnecessary.
+ */
+bool
+vc4_cl_references_bo(struct pipe_context *pctx, struct vc4_bo *bo,
+ bool include_reads)
{
struct vc4_context *vc4 = vc4_context(pctx);
if (!vc4->needs_flush)
- return;
+ return false;
+
+ /* Walk all the referenced BOs in the drawing command list to see if
+ * they match.
+ */
+ if (include_reads) {
+ struct vc4_bo **referenced_bos = vc4->bo_pointers.base;
+ for (int i = 0; i < cl_offset(&vc4->bo_handles) / 4; i++) {
+ if (referenced_bos[i] == bo) {
+ return true;
+ }
+ }
+ }
+ /* Also check for the Z/color buffers, since the references to those
+ * are only added immediately before submit.
+ */
struct vc4_surface *csurf = vc4_surface(vc4->framebuffer.cbufs[0]);
- struct vc4_resource *ctex = vc4_resource(csurf->base.texture);
- struct drm_vc4_submit_cl submit;
- memset(&submit, 0, sizeof(submit));
-
- submit.bo_handles = vc4->bo_handles.base;
- submit.bo_handle_count = (vc4->bo_handles.next -
- vc4->bo_handles.base) / 4;
- submit.bin_cl = vc4->bcl.base;
- submit.bin_cl_len = vc4->bcl.next - vc4->bcl.base;
- submit.render_cl = vc4->rcl.base;
- submit.render_cl_len = vc4->rcl.next - vc4->rcl.base;
- submit.shader_records = vc4->shader_rec.base;
- submit.shader_record_len = vc4->shader_rec.next - vc4->shader_rec.base;
- submit.shader_record_count = vc4->shader_rec_count;
- submit.uniforms = vc4->uniforms.base;
- submit.uniforms_len = vc4->uniforms.next - vc4->uniforms.base;
-
- if (!(vc4_debug & VC4_DEBUG_NORAST)) {
- int ret;
-
-#ifndef USE_VC4_SIMULATOR
- ret = drmIoctl(vc4->fd, DRM_IOCTL_VC4_SUBMIT_CL, &submit);
-#else
- ret = vc4_simulator_flush(vc4, &submit, csurf);
-#endif
- if (ret)
- errx(1, "VC4 submit failed\n");
+ if (csurf) {
+ struct vc4_resource *ctex = vc4_resource(csurf->base.texture);
+ if (ctex->bo == bo) {
+ return true;
+ }
}
- vc4_reset_cl(&vc4->bcl);
- vc4_reset_cl(&vc4->rcl);
- vc4_reset_cl(&vc4->shader_rec);
- vc4_reset_cl(&vc4->uniforms);
- vc4_reset_cl(&vc4->bo_handles);
-#ifdef USE_VC4_SIMULATOR
- vc4_reset_cl(&vc4->bo_pointers);
-#endif
- vc4->shader_rec_count = 0;
-
- vc4->needs_flush = false;
- vc4->dirty = ~0;
+ struct vc4_surface *zsurf = vc4_surface(vc4->framebuffer.zsbuf);
+ if (zsurf) {
+ struct vc4_resource *ztex =
+ vc4_resource(zsurf->base.texture);
+ if (ztex->bo == bo) {
+ return true;
+ }
+ }
- dump_fbo(vc4, ctex->bo);
+ return false;
}
static void
-vc4_pipe_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence,
- unsigned flags)
+vc4_invalidate_resource(struct pipe_context *pctx, struct pipe_resource *prsc)
{
- vc4_flush(pctx);
+ struct vc4_context *vc4 = vc4_context(pctx);
+ struct pipe_surface *zsurf = vc4->framebuffer.zsbuf;
+
+ if (zsurf && zsurf->texture == prsc)
+ vc4->resolve &= ~(PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL);
}
static void
if (vc4->primconvert)
util_primconvert_destroy(vc4->primconvert);
+ if (vc4->uploader)
+ u_upload_destroy(vc4->uploader);
+
util_slab_destroy(&vc4->transfer_pool);
- free(vc4);
+ pipe_surface_reference(&vc4->framebuffer.cbufs[0], NULL);
+ pipe_surface_reference(&vc4->framebuffer.zsbuf, NULL);
+
+ pipe_surface_reference(&vc4->color_write, NULL);
+ pipe_surface_reference(&vc4->color_read, NULL);
+
+ vc4_program_fini(pctx);
+
+ ralloc_free(vc4);
}
struct pipe_context *
-vc4_context_create(struct pipe_screen *pscreen, void *priv)
+vc4_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags)
{
struct vc4_screen *screen = vc4_screen(pscreen);
struct vc4_context *vc4;
uint32_t saved_shaderdb_flag = vc4_debug & VC4_DEBUG_SHADERDB;
vc4_debug &= ~VC4_DEBUG_SHADERDB;
- vc4 = CALLOC_STRUCT(vc4_context);
- if (vc4 == NULL)
+ vc4 = rzalloc(NULL, struct vc4_context);
+ if (!vc4)
return NULL;
struct pipe_context *pctx = &vc4->base;
pctx->priv = priv;
pctx->destroy = vc4_context_destroy;
pctx->flush = vc4_pipe_flush;
+ pctx->invalidate_resource = vc4_invalidate_resource;
vc4_draw_init(pctx);
vc4_state_init(pctx);
vc4_program_init(pctx);
+ vc4_query_init(pctx);
vc4_resource_context_init(pctx);
- vc4_init_cl(vc4, &vc4->bcl);
- vc4_init_cl(vc4, &vc4->rcl);
- vc4_init_cl(vc4, &vc4->shader_rec);
- vc4_init_cl(vc4, &vc4->bo_handles);
+ vc4_job_init(vc4);
- vc4->dirty = ~0;
vc4->fd = screen->fd;
- util_slab_create(&vc4->transfer_pool, sizeof(struct pipe_transfer),
+ util_slab_create(&vc4->transfer_pool, sizeof(struct vc4_transfer),
16, UTIL_SLAB_SINGLETHREADED);
vc4->blitter = util_blitter_create(pctx);
if (!vc4->blitter)
goto fail;
vc4->primconvert = util_primconvert_create(pctx,
- !((1 << PIPE_PRIM_QUADS) - 1));
+ (1 << PIPE_PRIM_QUADS) - 1);
if (!vc4->primconvert)
goto fail;
+ vc4->uploader = u_upload_create(pctx, 16 * 1024,
+ PIPE_BIND_INDEX_BUFFER,
+ PIPE_USAGE_STREAM);
+
vc4_debug |= saved_shaderdb_flag;
+ vc4->sample_mask = (1 << VC4_MAX_SAMPLES) - 1;
+
return &vc4->base;
fail:
projects / mesa.git / blobdiff