#include "util/u_inlines.h"
#include "util/u_memory.h"
#include "virgl_context.h"
+#include "virgl_encode.h"
#include "virgl_resource.h"
#include "virgl_screen.h"
struct virgl_resource *vbuf = virgl_resource(resource);
struct virgl_transfer *trans;
enum virgl_transfer_map_type map_type;
+ void *map_addr;
trans = virgl_resource_create_transfer(&vctx->transfer_pool, resource,
&vbuf->metadata, level, usage, box);
switch (map_type) {
case VIRGL_TRANSFER_MAP_HW_RES:
trans->hw_res_map = vs->vws->resource_map(vs->vws, vbuf->hw_res);
+ if (trans->hw_res_map)
+ map_addr = trans->hw_res_map + trans->offset;
+ else
+ map_addr = NULL;
+ break;
+ case VIRGL_TRANSFER_MAP_STAGING:
+ map_addr = virgl_transfer_uploader_map(vctx, trans);
+ /* Copy transfers don't make use of hw_res_map at the moment. */
+ trans->hw_res_map = NULL;
break;
case VIRGL_TRANSFER_MAP_ERROR:
default:
trans->hw_res_map = NULL;
+ map_addr = NULL;
break;
}
- if (!trans->hw_res_map) {
+ if (!map_addr) {
virgl_resource_destroy_transfer(&vctx->transfer_pool, trans);
return NULL;
}
util_range_add(&vbuf->valid_buffer_range, box->x, box->x + box->width);
*transfer = &trans->base;
- return trans->hw_res_map + trans->offset;
+ return map_addr;
}
static void virgl_buffer_transfer_unmap(struct pipe_context *ctx,
{
struct virgl_context *vctx = virgl_context(ctx);
struct virgl_transfer *trans = virgl_transfer(transfer);
+ struct virgl_screen *vs = virgl_screen(ctx->screen);
+ struct pipe_resource *res = transfer->resource;
+
+ /* We don't need to transfer the contents of staging buffers, since they
+ * don't have any host-side storage. */
+ if (pipe_to_virgl_bind(vs, res->bind, res->flags) == VIRGL_BIND_STAGING) {
+ virgl_resource_destroy_transfer(&vctx->transfer_pool, trans);
+ return;
+ }
if (trans->base.usage & PIPE_TRANSFER_WRITE) {
if (transfer->usage & PIPE_TRANSFER_FLUSH_EXPLICIT) {
trans->offset = transfer->box.x;
}
- virgl_transfer_queue_unmap(&vctx->queue, trans);
+ if (trans->copy_src_res) {
+ virgl_encode_copy_transfer(vctx, trans);
+ /* It's now safe for other mappings to use the transfer_uploader. */
+ vctx->transfer_uploader_in_use = false;
+ virgl_resource_destroy_transfer(&vctx->transfer_pool, trans);
+ } else {
+ virgl_transfer_queue_unmap(&vctx->queue, trans);
+ }
} else
virgl_resource_destroy_transfer(&vctx->transfer_pool, trans);
}
rs->vws->cmd_buf_destroy(vctx->cbuf);
if (vctx->uploader)
u_upload_destroy(vctx->uploader);
+ if (vctx->transfer_uploader)
+ u_upload_destroy(vctx->transfer_uploader);
util_primconvert_destroy(vctx->primconvert);
virgl_transfer_queue_fini(&vctx->queue);
goto fail;
vctx->base.stream_uploader = vctx->uploader;
vctx->base.const_uploader = vctx->uploader;
+ /* Use a custom/staging buffer for the transfer uploader, since we are
+ * using it only for copies to other resources.
+ */
+ if ((rs->caps.caps.v2.capability_bits & VIRGL_CAP_COPY_TRANSFER) &&
+ vctx->encoded_transfers) {
+ vctx->transfer_uploader = u_upload_create(&vctx->base, 1024 * 1024,
+ PIPE_BIND_CUSTOM,
+ PIPE_USAGE_STAGING,
+ VIRGL_RESOURCE_FLAG_STAGING);
+ if (!vctx->transfer_uploader)
+ goto fail;
+ }
vctx->hw_sub_ctx_id = rs->sub_ctx_id++;
virgl_encoder_create_sub_ctx(vctx, vctx->hw_sub_ctx_id);
return &vctx->base;
fail:
+ virgl_context_destroy(&vctx->base);
return NULL;
}
struct slab_child_pool transfer_pool;
struct virgl_transfer_queue queue;
struct u_upload_mgr *uploader;
+ struct u_upload_mgr *transfer_uploader;
+ bool transfer_uploader_in_use;
bool encoded_transfers;
struct pipe_vertex_buffer vertex_buffer[PIPE_MAX_ATTRIBS];
#include "util/u_format.h"
#include "util/u_inlines.h"
#include "util/u_memory.h"
+#include "util/u_upload_mgr.h"
#include "virgl_context.h"
#include "virgl_resource.h"
#include "virgl_screen.h"
virgl_resource_transfer_prepare(struct virgl_context *vctx,
struct virgl_transfer *xfer)
{
- struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
+ struct virgl_screen *vs = virgl_screen(vctx->base.screen);
+ struct virgl_winsys *vws = vs->vws;
struct virgl_resource *res = virgl_resource(xfer->base.resource);
enum virgl_transfer_map_type map_type = VIRGL_TRANSFER_MAP_HW_RES;
+ bool unsynchronized = xfer->base.usage & PIPE_TRANSFER_UNSYNCHRONIZED;
+ bool discard = xfer->base.usage & (PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE |
+ PIPE_TRANSFER_DISCARD_RANGE);
bool flush;
bool readback;
bool wait;
+ bool copy_transfer;
/* there is no way to map the host storage currently */
if (xfer->base.usage & PIPE_TRANSFER_MAP_DIRECTLY)
flush = virgl_res_needs_flush(vctx, xfer);
readback = virgl_res_needs_readback(vctx, res, xfer->base.usage,
xfer->base.level);
+
+ /* Check if we should perform a copy transfer through the transfer_uploader. */
+ copy_transfer = res->u.b.target == PIPE_BUFFER &&
+ discard &&
+ !readback &&
+ !unsynchronized &&
+ vctx->transfer_uploader &&
+ !vctx->transfer_uploader_in_use &&
+ (flush || vws->resource_is_busy(vws, res->hw_res));
+
/* We need to wait for all cmdbufs, current or previous, that access the
* resource to finish unless synchronization is disabled.
*/
- wait = !(xfer->base.usage & PIPE_TRANSFER_UNSYNCHRONIZED);
+ wait = !unsynchronized;
/* When the transfer range consists of only uninitialized data, we can
* assume the GPU is not accessing the range and readback is unnecessary.
flush = false;
readback = false;
wait = false;
+ copy_transfer = false;
+ }
+
+ /* When performing a copy transfer there is no need to flush or wait for
+ * the target resource.
+ */
+ if (copy_transfer) {
+ flush = false;
+ wait = false;
}
/* readback has some implications */
if (wait)
vws->resource_wait(vws, res->hw_res);
+ if (copy_transfer)
+ map_type = VIRGL_TRANSFER_MAP_STAGING;
+
return map_type;
}
res->clean_mask &= ~(1 << level);
}
}
+
+void *virgl_transfer_uploader_map(struct virgl_context *vctx,
+ struct virgl_transfer *vtransfer)
+{
+ struct virgl_resource *vres = virgl_resource(vtransfer->base.resource);
+ unsigned size;
+ unsigned align_offset;
+ void *map_addr;
+
+ assert(vctx->transfer_uploader);
+ assert(!vctx->transfer_uploader_in_use);
+
+ size = vtransfer->base.box.width;
+
+ /* For buffers we need to ensure that the start of the buffer would be
+ * aligned to VIRGL_MAP_BUFFER_ALIGNMENT, even if our transfer doesn't
+ * actually include it. To achieve this we may need to allocate a slightly
+ * larger range from the upload buffer, and later update the uploader
+ * resource offset and map address to point to the requested x coordinate
+ * within that range.
+ *
+ * 0 A 2A 3A
+ * |-------|---bbbb|bbbbb--|
+ * |--------| ==> size
+ * |---| ==> align_offset
+ * |------------| ==> allocation of size + align_offset
+ */
+ align_offset = vtransfer->base.box.x % VIRGL_MAP_BUFFER_ALIGNMENT;
+
+ u_upload_alloc(vctx->transfer_uploader, 0, size + align_offset,
+ VIRGL_MAP_BUFFER_ALIGNMENT,
+ &vtransfer->copy_src_offset,
+ &vtransfer->copy_src_res, &map_addr);
+ if (map_addr) {
+ /* Update source offset and address to point to the requested x coordinate
+ * if we have an align_offset (see above for more information). */
+ vtransfer->copy_src_offset += align_offset;
+ map_addr += align_offset;
+
+ /* Mark as dirty, since we are updating the host side resource
+ * without going through the corresponding guest side resource, and
+ * hence the two will diverge.
+ */
+ virgl_resource_dirty(vres, vtransfer->base.level);
+
+ /* The pointer returned by u_upload_alloc already has +offset
+ * applied. */
+ vctx->transfer_uploader_in_use = true;
+ }
+
+ return map_addr;
+}
enum virgl_transfer_map_type {
VIRGL_TRANSFER_MAP_ERROR = -1,
VIRGL_TRANSFER_MAP_HW_RES,
+ /* Map a range of a staging buffer. The updated contents should be transferred
+ * with a copy transfer.
+ */
+ VIRGL_TRANSFER_MAP_STAGING,
};
struct virgl_transfer {
void virgl_resource_dirty(struct virgl_resource *res, uint32_t level);
+void *virgl_transfer_uploader_map(struct virgl_context *vctx,
+ struct virgl_transfer *vtransfer);
+
#endif
struct virgl_transfer *transfer)
{
uint32_t dwords = VIRGL_TRANSFER3D_SIZE + 1;
-
if (queue->tbuf) {
if (queue->num_dwords + dwords >= VIRGL_MAX_TBUF_DWORDS) {
struct list_iteration_args iter;
projects / mesa.git / commitdiff