From cbb13fae33a8b8e72db4200dfeec1b72528763db Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Tue, 19 Oct 2021 23:55:27 -0500 Subject: [PATCH] anv: Add a BO sync type This is copy+paste from the BO implementation of anv_fence Reviewed-by: Lionel Landwerlin Part-of: --- src/intel/vulkan/anv_bo_sync.c | 235 +++++++++++++++++++++++++++++++++ src/intel/vulkan/anv_private.h | 34 +++++ src/intel/vulkan/meson.build | 1 + 3 files changed, 270 insertions(+) create mode 100644 src/intel/vulkan/anv_bo_sync.c diff --git a/src/intel/vulkan/anv_bo_sync.c b/src/intel/vulkan/anv_bo_sync.c new file mode 100644 index 00000000000..233ebe971be --- /dev/null +++ b/src/intel/vulkan/anv_bo_sync.c @@ -0,0 +1,235 @@ +/* + * Copyright © 2021 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include "anv_private.h" + +#include "util/os_time.h" + +static struct anv_bo_sync * +to_anv_bo_sync(struct vk_sync *sync) +{ + assert(sync->type == &anv_bo_sync_type); + return container_of(sync, struct anv_bo_sync, sync); +} + +static VkResult +anv_bo_sync_init(struct vk_device *vk_device, + struct vk_sync *vk_sync, + uint64_t initial_value) +{ + struct anv_device *device = container_of(vk_device, struct anv_device, vk); + struct anv_bo_sync *sync = to_anv_bo_sync(vk_sync); + + sync->state = initial_value ? ANV_BO_SYNC_STATE_SIGNALED : + ANV_BO_SYNC_STATE_RESET; + + return anv_device_alloc_bo(device, "bo-sync", 4096, + ANV_BO_ALLOC_EXTERNAL | + ANV_BO_ALLOC_IMPLICIT_SYNC, + 0 /* explicit_address */, + &sync->bo); +} + +static void +anv_bo_sync_finish(struct vk_device *vk_device, + struct vk_sync *vk_sync) +{ + struct anv_device *device = container_of(vk_device, struct anv_device, vk); + struct anv_bo_sync *sync = to_anv_bo_sync(vk_sync); + + anv_device_release_bo(device, sync->bo); +} + +static VkResult +anv_bo_sync_reset(struct vk_device *vk_device, + struct vk_sync *vk_sync) +{ + struct anv_bo_sync *sync = to_anv_bo_sync(vk_sync); + + sync->state = ANV_BO_SYNC_STATE_RESET; + + return VK_SUCCESS; +} + +static int64_t +anv_get_relative_timeout(uint64_t abs_timeout) +{ + uint64_t now = os_time_get_nano(); + + /* We don't want negative timeouts. + * + * DRM_IOCTL_I915_GEM_WAIT uses a signed 64 bit timeout and is + * supposed to block indefinitely timeouts < 0. Unfortunately, + * this was broken for a couple of kernel releases. Since there's + * no way to know whether or not the kernel we're using is one of + * the broken ones, the best we can do is to clamp the timeout to + * INT64_MAX. This limits the maximum timeout from 584 years to + * 292 years - likely not a big deal. + */ + if (abs_timeout < now) + return 0; + + uint64_t rel_timeout = abs_timeout - now; + if (rel_timeout > (uint64_t) INT64_MAX) + rel_timeout = INT64_MAX; + + return rel_timeout; +} + +static VkResult +anv_bo_sync_wait(struct vk_device *vk_device, + uint32_t wait_count, + const struct vk_sync_wait *waits, + enum vk_sync_wait_flags wait_flags, + uint64_t abs_timeout_ns) +{ + struct anv_device *device = container_of(vk_device, struct anv_device, vk); + VkResult result; + + uint32_t pending = wait_count; + while (pending) { + pending = 0; + bool signaled = false; + for (uint32_t i = 0; i < wait_count; i++) { + struct anv_bo_sync *sync = to_anv_bo_sync(waits[i].sync); + switch (sync->state) { + case ANV_BO_SYNC_STATE_RESET: + /* This fence hasn't been submitted yet, we'll catch it the next + * time around. Yes, this may mean we dead-loop but, short of + * lots of locking and a condition variable, there's not much that + * we can do about that. + */ + assert(!(wait_flags & VK_SYNC_WAIT_PENDING)); + pending++; + continue; + + case ANV_BO_SYNC_STATE_SIGNALED: + /* This fence is not pending. If waitAll isn't set, we can return + * early. Otherwise, we have to keep going. + */ + if (wait_flags & VK_SYNC_WAIT_ANY) + return VK_SUCCESS; + continue; + + case ANV_BO_SYNC_STATE_SUBMITTED: + /* These are the fences we really care about. Go ahead and wait + * on it until we hit a timeout. + */ + if (!(wait_flags & VK_SYNC_WAIT_PENDING)) { + uint64_t rel_timeout = anv_get_relative_timeout(abs_timeout_ns); + result = anv_device_wait(device, sync->bo, rel_timeout); + /* This also covers VK_TIMEOUT */ + if (result != VK_SUCCESS) + return result; + + sync->state = ANV_BO_SYNC_STATE_SIGNALED; + signaled = true; + } + if (wait_flags & VK_SYNC_WAIT_ANY) + return VK_SUCCESS; + break; + + default: + unreachable("Invalid BO sync state"); + } + } + + if (pending && !signaled) { + /* If we've hit this then someone decided to vkWaitForFences before + * they've actually submitted any of them to a queue. This is a + * fairly pessimal case, so it's ok to lock here and use a standard + * pthreads condition variable. + */ + pthread_mutex_lock(&device->mutex); + + /* It's possible that some of the fences have changed state since the + * last time we checked. Now that we have the lock, check for + * pending fences again and don't wait if it's changed. + */ + uint32_t now_pending = 0; + for (uint32_t i = 0; i < wait_count; i++) { + struct anv_bo_sync *sync = to_anv_bo_sync(waits[i].sync); + if (sync->state == ANV_BO_SYNC_STATE_RESET) + now_pending++; + } + assert(now_pending <= pending); + + if (now_pending == pending) { + struct timespec abstime = { + .tv_sec = abs_timeout_ns / NSEC_PER_SEC, + .tv_nsec = abs_timeout_ns % NSEC_PER_SEC, + }; + + ASSERTED int ret; + ret = pthread_cond_timedwait(&device->queue_submit, + &device->mutex, &abstime); + assert(ret != EINVAL); + if (os_time_get_nano() >= abs_timeout_ns) { + pthread_mutex_unlock(&device->mutex); + return VK_TIMEOUT; + } + } + + pthread_mutex_unlock(&device->mutex); + } + } + + return VK_SUCCESS; +} + +const struct vk_sync_type anv_bo_sync_type = { + .size = sizeof(struct anv_bo_sync), + .features = VK_SYNC_FEATURE_BINARY | + VK_SYNC_FEATURE_GPU_WAIT | + VK_SYNC_FEATURE_GPU_MULTI_WAIT | + VK_SYNC_FEATURE_CPU_WAIT | + VK_SYNC_FEATURE_CPU_RESET | + VK_SYNC_FEATURE_WAIT_ANY | + VK_SYNC_FEATURE_WAIT_PENDING, + .init = anv_bo_sync_init, + .finish = anv_bo_sync_finish, + .reset = anv_bo_sync_reset, + .wait_many = anv_bo_sync_wait, +}; +VK_DECL_TIMELINE_TYPE(anv_bo_timeline_type, &anv_bo_sync_type); + +VkResult +anv_sync_create_for_bo(struct anv_device *device, + struct anv_bo *bo, + struct vk_sync **sync_out) +{ + struct anv_bo_sync *bo_sync; + + bo_sync = vk_alloc(&device->vk.alloc, sizeof(*bo_sync), 8, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); + if (bo_sync == NULL) + return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY); + + bo_sync->sync.type = &anv_bo_sync_type; + bo_sync->state = ANV_BO_SYNC_STATE_SUBMITTED; + bo_sync->bo = anv_bo_ref(bo); + + *sync_out = &bo_sync->sync; + + return VK_SUCCESS; +} diff --git a/src/intel/vulkan/anv_private.h b/src/intel/vulkan/anv_private.h index cea41a66804..edccfbc2a55 100644 --- a/src/intel/vulkan/anv_private.h +++ b/src/intel/vulkan/anv_private.h @@ -71,6 +71,8 @@ #include "vk_instance.h" #include "vk_physical_device.h" #include "vk_shader_module.h" +#include "vk_sync.h" +#include "vk_timeline.h" #include "vk_util.h" #include "vk_command_buffer.h" #include "vk_queue.h" @@ -3246,6 +3248,38 @@ void anv_cmd_buffer_dump(struct anv_cmd_buffer *cmd_buffer); void anv_cmd_emit_conditional_render_predicate(struct anv_cmd_buffer *cmd_buffer); +enum anv_bo_sync_state { + /** Indicates that this is a new (or newly reset fence) */ + ANV_BO_SYNC_STATE_RESET, + + /** Indicates that this fence has been submitted to the GPU but is still + * (as far as we know) in use by the GPU. + */ + ANV_BO_SYNC_STATE_SUBMITTED, + + ANV_BO_SYNC_STATE_SIGNALED, +}; + +struct anv_bo_sync { + struct vk_sync sync; + + enum anv_bo_sync_state state; + struct anv_bo *bo; +}; + +extern const struct vk_sync_type anv_bo_sync_type; +extern const struct vk_timeline_type anv_bo_timeline_type; + +static inline bool +vk_sync_is_anv_bo_sync(const struct vk_sync *sync) +{ + return sync->type == &anv_bo_sync_type; +} + +VkResult anv_sync_create_for_bo(struct anv_device *device, + struct anv_bo *bo, + struct vk_sync **sync_out); + enum anv_fence_type { ANV_FENCE_TYPE_NONE = 0, ANV_FENCE_TYPE_BO, diff --git a/src/intel/vulkan/meson.build b/src/intel/vulkan/meson.build index 6ec5d133870..fa693551030 100644 --- a/src/intel/vulkan/meson.build +++ b/src/intel/vulkan/meson.build @@ -88,6 +88,7 @@ libanv_files = files( 'anv_android.h', 'anv_batch_chain.c', 'anv_blorp.c', + 'anv_bo_sync.c', 'anv_cmd_buffer.c', 'anv_descriptor_set.c', 'anv_device.c',