From: Marek Olšák <marek.ol...@amd.com>
---
src/gallium/auxiliary/util/u_threaded_context.c | 19 ++++++++++++-------
1 file changed, 12 insertions(+), 7 deletions(-)
diff --git a/src/gallium/auxiliary/util/u_threaded_context.c
b/src/gallium/auxiliary/util/u_threaded_context.c
index 7e28b87..0f23258 100644
--- a/src/gallium/auxiliary/util/u_threaded_context.c
+++ b/src/gallium/auxiliary/util/u_threaded_context.c
@@ -1269,45 +1269,53 @@ tc_invalidate_buffer(struct threaded_context *tc,
tc_set_resource_reference(&p->dst, &tbuf->b);
tc_set_resource_reference(&p->src, new_buf);
return true;
}
static unsigned
tc_improve_map_buffer_flags(struct threaded_context *tc,
struct threaded_resource *tres, unsigned usage,
unsigned offset, unsigned size)
{
+ /* Never invalidate inside the driver and never infer "unsynchronized". */
+ unsigned tc_flags = TC_TRANSFER_MAP_NO_INVALIDATE |
+ TC_TRANSFER_MAP_NO_INFER_UNSYNCHRONIZED;
+
+ /* Prevent a reentry. */
+ if (usage & tc_flags)
+ return usage;
+
/* Sparse buffers can't be mapped directly and can't be reallocated
* (fully invalidated). That may just be a radeonsi limitation, but
* the threaded context must obey it with radeonsi.
*/
if (tres->b.flags & PIPE_RESOURCE_FLAG_SPARSE) {
/* We can use DISCARD_RANGE instead of full discard. This is the only
* fast path for sparse buffers that doesn't need thread synchronization.
*/
if (usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE)
usage |= PIPE_TRANSFER_DISCARD_RANGE;
/* Allow DISCARD_WHOLE_RESOURCE and infering UNSYNCHRONIZED in drivers.
* The threaded context doesn't do unsychronized mappings and invalida-
* tions of sparse buffers, therefore a correct driver behavior won't
* result in an incorrect behavior with the threaded context.
*/
return usage;
}
+ usage |= tc_flags;
+
/* Handle CPU reads trivially. */
if (usage & PIPE_TRANSFER_READ) {
/* Drivers aren't allowed to do buffer invalidations. */
- return (usage & ~PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) |
- TC_TRANSFER_MAP_NO_INVALIDATE |
- TC_TRANSFER_MAP_NO_INFER_UNSYNCHRONIZED;
+ return usage & ~PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE;
}
/* See if the buffer range being mapped has never been initialized,
* in which case it can be mapped unsynchronized. */
if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED) &&
!tres->is_shared &&
!util_ranges_intersect(&tres->valid_buffer_range, offset, offset +
size))
usage |= PIPE_TRANSFER_UNSYNCHRONIZED;
if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) {
@@ -1335,24 +1343,21 @@ tc_improve_map_buffer_flags(struct threaded_context *tc,
PIPE_TRANSFER_PERSISTENT) ||
tres->is_user_ptr)
usage &= ~PIPE_TRANSFER_DISCARD_RANGE;
/* Unsychronized buffer mappings don't have to synchronize the thread. */
if (usage & PIPE_TRANSFER_UNSYNCHRONIZED) {
usage &= ~PIPE_TRANSFER_DISCARD_RANGE;
usage |= TC_TRANSFER_MAP_THREADED_UNSYNC; /* notify the driver */
}
- /* Never invalidate inside the driver and never infer "unsynchronized". */
- return usage |
- TC_TRANSFER_MAP_NO_INVALIDATE |
- TC_TRANSFER_MAP_NO_INFER_UNSYNCHRONIZED;
+ return usage;
}
static void *
tc_transfer_map(struct pipe_context *_pipe,
struct pipe_resource *resource, unsigned level,
unsigned usage, const struct pipe_box *box,
struct pipe_transfer **transfer)
{
struct threaded_context *tc = threaded_context(_pipe);
struct threaded_resource *tres = threaded_resource(resource);
--
2.7.4
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
