AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

radv: Replace pthread mutex with mtx_t

Browse Source 
Reviewed-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/7866>
This commit is contained in:
James Park
2020-11-26 19:30:47 -08:00
committed by Marge Bot
parent aefaceab09
commit 63dc2a53af
3 changed files with 52 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/amd/vulkan/radv_device.c
+43 -43
View File
@@ -2356,9 +2356,9 @@ radv_queue_init(struct radv_device *device, struct radv_queue *queue,
return vk_error(device->instance, result);
list_inithead(&queue->pending_submissions);
pthread_mutex_init(&queue->pending_mutex, NULL);
mtx_init(&queue->pending_mutex, mtx_plain);
pthread_mutex_init(&queue->thread_mutex, NULL);
mtx_init(&queue->thread_mutex, mtx_plain);
if (u_cnd_monotonic_init(&queue->thread_cond)) {
result = VK_ERROR_INITIALIZATION_FAILED;
return vk_error(device->instance, result);
@@ -2382,8 +2382,8 @@ radv_queue_finish(struct radv_queue *queue)
u_cnd_monotonic_destroy(&queue->thread_cond);
}
pthread_mutex_destroy(&queue->pending_mutex);
pthread_mutex_destroy(&queue->thread_mutex);
mtx_destroy(&queue->pending_mutex);
mtx_destroy(&queue->thread_mutex);
queue->device->ws->ctx_destroy(queue->hw_ctx);
}
@@ -2594,7 +2594,7 @@ static VkResult radv_device_init_border_color(struct radv_device *device)
device->ws->buffer_map(device->border_color_data.bo);
if (!device->border_color_data.colors_gpu_ptr)
return vk_error(device->physical_device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY);
pthread_mutex_init(&device->border_color_data.mutex, NULL);
mtx_init(&device->border_color_data.mutex, mtx_plain);
return VK_SUCCESS;
}
@@ -2604,7 +2604,7 @@ static void radv_device_finish_border_color(struct radv_device *device)
if (device->border_color_data.bo) {
device->ws->buffer_destroy(device->border_color_data.bo);
pthread_mutex_destroy(&device->border_color_data.mutex);
mtx_destroy(&device->border_color_data.mutex);
}
}
@@ -4047,7 +4047,7 @@ static VkResult radv_alloc_sem_counts(struct radv_device *device,
counts->sem[sem_idx++] = sems[i]->ws_sem;
break;
case RADV_SEMAPHORE_TIMELINE: {
pthread_mutex_lock(&sems[i]->timeline.mutex);
mtx_lock(&sems[i]->timeline.mutex);
struct radv_timeline_point *point = NULL;
if (is_signal) {
point = radv_timeline_add_point_locked(device, &sems[i]->timeline, timeline_values[i]);
@@ -4055,7 +4055,7 @@ static VkResult radv_alloc_sem_counts(struct radv_device *device,
point = radv_timeline_find_point_at_least_locked(device, &sems[i]->timeline, timeline_values[i]);
}
pthread_mutex_unlock(&sems[i]->timeline.mutex);
mtx_unlock(&sems[i]->timeline.mutex);
if (point) {
counts->syncobj[non_reset_idx++] = point->syncobj;
@@ -4148,23 +4148,23 @@ radv_finalize_timelines(struct radv_device *device,
{
for (uint32_t i = 0; i < num_wait_sems; ++i) {
if (wait_sems[i] && wait_sems[i]->kind == RADV_SEMAPHORE_TIMELINE) {
pthread_mutex_lock(&wait_sems[i]->timeline.mutex);
mtx_lock(&wait_sems[i]->timeline.mutex);
struct radv_timeline_point *point =
radv_timeline_find_point_at_least_locked(device, &wait_sems[i]->timeline, wait_values[i]);
point->wait_count -= 2;
pthread_mutex_unlock(&wait_sems[i]->timeline.mutex);
mtx_unlock(&wait_sems[i]->timeline.mutex);
}
}
for (uint32_t i = 0; i < num_signal_sems; ++i) {
if (signal_sems[i] && signal_sems[i]->kind == RADV_SEMAPHORE_TIMELINE) {
pthread_mutex_lock(&signal_sems[i]->timeline.mutex);
mtx_lock(&signal_sems[i]->timeline.mutex);
struct radv_timeline_point *point =
radv_timeline_find_point_at_least_locked(device, &signal_sems[i]->timeline, signal_values[i]);
signal_sems[i]->timeline.highest_submitted =
MAX2(signal_sems[i]->timeline.highest_submitted, point->value);
point->wait_count -= 2;
radv_timeline_trigger_waiters_locked(&signal_sems[i]->timeline, processing_list);
pthread_mutex_unlock(&signal_sems[i]->timeline.mutex);
mtx_unlock(&signal_sems[i]->timeline.mutex);
} else if (signal_sems[i] && signal_sems[i]->kind == RADV_SEMAPHORE_TIMELINE_SYNCOBJ) {
signal_sems[i]->timeline_syncobj.max_point =
MAX2(signal_sems[i]->timeline_syncobj.max_point, signal_values[i]);
@@ -4438,7 +4438,7 @@ radv_queue_enqueue_submission(struct radv_deferred_queue_submission *submission,
struct radv_timeline_waiter *waiter = submission->wait_nodes;
for (uint32_t i = 0; i < submission->wait_semaphore_count; ++i) {
if (submission->wait_semaphores[i]->kind == RADV_SEMAPHORE_TIMELINE) {
pthread_mutex_lock(&submission->wait_semaphores[i]->timeline.mutex);
mtx_lock(&submission->wait_semaphores[i]->timeline.mutex);
if (submission->wait_semaphores[i]->timeline.highest_submitted < submission->wait_values[i]) {
++wait_cnt;
waiter->value = submission->wait_values[i];
@@ -4446,16 +4446,16 @@ radv_queue_enqueue_submission(struct radv_deferred_queue_submission *submission,
list_addtail(&waiter->list, &submission->wait_semaphores[i]->timeline.waiters);
++waiter;
}
pthread_mutex_unlock(&submission->wait_semaphores[i]->timeline.mutex);
mtx_unlock(&submission->wait_semaphores[i]->timeline.mutex);
}
}
pthread_mutex_lock(&submission->queue->pending_mutex);
mtx_lock(&submission->queue->pending_mutex);
bool is_first = list_is_empty(&submission->queue->pending_submissions);
list_addtail(&submission->queue_pending_list, &submission->queue->pending_submissions);
pthread_mutex_unlock(&submission->queue->pending_mutex);
mtx_unlock(&submission->queue->pending_mutex);
/* If there is already a submission in the queue, that will decrement the counter by 1 when
* submitted, but if the queue was empty, we decrement ourselves as there is no previous
@@ -4474,7 +4474,7 @@ static void
radv_queue_submission_update_queue(struct radv_deferred_queue_submission *submission,
struct list_head *processing_list)
{
pthread_mutex_lock(&submission->queue->pending_mutex);
mtx_lock(&submission->queue->pending_mutex);
list_del(&submission->queue_pending_list);
/* trigger the next submission in the queue. */
@@ -4485,7 +4485,7 @@ radv_queue_submission_update_queue(struct radv_deferred_queue_submission *submis
queue_pending_list);
radv_queue_trigger_submission(next_submission, 1, processing_list);
}
pthread_mutex_unlock(&submission->queue->pending_mutex);
mtx_unlock(&submission->queue->pending_mutex);
u_cnd_monotonic_broadcast(&submission->queue->device->timeline_cond);
}
@@ -4723,7 +4723,7 @@ static void* radv_queue_submission_thread_run(void *q)
{
struct radv_queue *queue = q;
pthread_mutex_lock(&queue->thread_mutex);
mtx_lock(&queue->thread_mutex);
while (!p_atomic_read(&queue->thread_exit)) {
struct radv_deferred_queue_submission *submission = queue->thread_submission;
struct list_head processing_list;
@@ -4732,7 +4732,7 @@ static void* radv_queue_submission_thread_run(void *q)
u_cnd_monotonic_wait(&queue->thread_cond, &queue->thread_mutex);
continue;
}
pthread_mutex_unlock(&queue->thread_mutex);
mtx_unlock(&queue->thread_mutex);
/* Wait at most 5 seconds so we have a chance to notice shutdown when
* a semaphore never gets signaled. If it takes longer we just retry
@@ -4740,7 +4740,7 @@ static void* radv_queue_submission_thread_run(void *q)
result = wait_for_submission_timelines_available(submission,
radv_get_absolute_timeout(5000000000));
if (result != VK_SUCCESS) {
pthread_mutex_lock(&queue->thread_mutex);
mtx_lock(&queue->thread_mutex);
continue;
}
@@ -4752,9 +4752,9 @@ static void* radv_queue_submission_thread_run(void *q)
list_addtail(&submission->processing_list, &processing_list);
result = radv_process_submissions(&processing_list);
pthread_mutex_lock(&queue->thread_mutex);
mtx_lock(&queue->thread_mutex);
}
pthread_mutex_unlock(&queue->thread_mutex);
mtx_unlock(&queue->thread_mutex);
return NULL;
}
@@ -4773,7 +4773,7 @@ radv_queue_trigger_submission(struct radv_deferred_queue_submission *submission,
return VK_SUCCESS;
}
pthread_mutex_lock(&queue->thread_mutex);
mtx_lock(&queue->thread_mutex);
/* A submission can only be ready for the thread if it doesn't have
* any predecessors in the same queue, so there can only be one such
@@ -4786,7 +4786,7 @@ radv_queue_trigger_submission(struct radv_deferred_queue_submission *submission,
ret = pthread_create(&queue->submission_thread, NULL,
radv_queue_submission_thread_run, queue);
if (ret) {
pthread_mutex_unlock(&queue->thread_mutex);
mtx_unlock(&queue->thread_mutex);
return vk_errorf(queue->device->instance,
VK_ERROR_DEVICE_LOST,
"Failed to start submission thread");
@@ -4795,7 +4795,7 @@ radv_queue_trigger_submission(struct radv_deferred_queue_submission *submission,
}
queue->thread_submission = submission;
pthread_mutex_unlock(&queue->thread_mutex);
mtx_unlock(&queue->thread_mutex);
u_cnd_monotonic_signal(&queue->thread_cond);
return VK_SUCCESS;
@@ -4947,11 +4947,11 @@ VkResult radv_QueueWaitIdle(
if (radv_device_is_lost(queue->device))
return VK_ERROR_DEVICE_LOST;
pthread_mutex_lock(&queue->pending_mutex);
mtx_lock(&queue->pending_mutex);
while (!list_is_empty(&queue->pending_submissions)) {
u_cnd_monotonic_wait(&queue->device->timeline_cond, &queue->pending_mutex);
}
pthread_mutex_unlock(&queue->pending_mutex);
mtx_unlock(&queue->pending_mutex);
if (!queue->device->ws->ctx_wait_idle(queue->hw_ctx,
radv_queue_family_to_ring(queue->queue_family_index),
@@ -5999,7 +5999,7 @@ radv_create_timeline(struct radv_timeline *timeline, uint64_t value)
list_inithead(&timeline->points);
list_inithead(&timeline->free_points);
list_inithead(&timeline->waiters);
pthread_mutex_init(&timeline->mutex, NULL);
mtx_init(&timeline->mutex, mtx_plain);
}
static void
@@ -6018,7 +6018,7 @@ radv_destroy_timeline(struct radv_device *device,
device->ws->destroy_syncobj(device->ws, point->syncobj);
free(point);
}
pthread_mutex_destroy(&timeline->mutex);
mtx_destroy(&timeline->mutex);
}
static void
@@ -6114,7 +6114,7 @@ radv_timeline_wait(struct radv_device *device,
uint64_t value,
uint64_t abs_timeout)
{
pthread_mutex_lock(&timeline->mutex);
mtx_lock(&timeline->mutex);
while(timeline->highest_submitted < value) {
struct timespec abstime;
@@ -6123,21 +6123,21 @@ radv_timeline_wait(struct radv_device *device,
u_cnd_monotonic_timedwait(&device->timeline_cond, &timeline->mutex, &abstime);
if (radv_get_current_time() >= abs_timeout && timeline->highest_submitted < value) {
pthread_mutex_unlock(&timeline->mutex);
mtx_unlock(&timeline->mutex);
return VK_TIMEOUT;
}
}
struct radv_timeline_point *point = radv_timeline_find_point_at_least_locked(device, timeline, value);
pthread_mutex_unlock(&timeline->mutex);
mtx_unlock(&timeline->mutex);
if (!point)
return VK_SUCCESS;
bool success = device->ws->wait_syncobj(device->ws, &point->syncobj, 1, true, abs_timeout);
pthread_mutex_lock(&timeline->mutex);
mtx_lock(&timeline->mutex);
point->wait_count--;
pthread_mutex_unlock(&timeline->mutex);
mtx_unlock(&timeline->mutex);
return success ? VK_SUCCESS : VK_TIMEOUT;
}
@@ -6291,10 +6291,10 @@ radv_GetSemaphoreCounterValue(VkDevice _device,
switch (part->kind) {
case RADV_SEMAPHORE_TIMELINE: {
pthread_mutex_lock(&part->timeline.mutex);
mtx_lock(&part->timeline.mutex);
radv_timeline_gc_locked(device, &part->timeline);
*pValue = part->timeline.highest_signaled;
pthread_mutex_unlock(&part->timeline.mutex);
mtx_unlock(&part->timeline.mutex);
return VK_SUCCESS;
}
case RADV_SEMAPHORE_TIMELINE_SYNCOBJ: {
@@ -6384,7 +6384,7 @@ radv_SignalSemaphore(VkDevice _device,
switch(part->kind) {
case RADV_SEMAPHORE_TIMELINE: {
pthread_mutex_lock(&part->timeline.mutex);
mtx_lock(&part->timeline.mutex);
radv_timeline_gc_locked(device, &part->timeline);
part->timeline.highest_submitted = MAX2(part->timeline.highest_submitted, pSignalInfo->value);
part->timeline.highest_signaled = MAX2(part->timeline.highest_signaled, pSignalInfo->value);
@@ -6392,7 +6392,7 @@ radv_SignalSemaphore(VkDevice _device,
struct list_head processing_list;
list_inithead(&processing_list);
radv_timeline_trigger_waiters_locked(&part->timeline, &processing_list);
pthread_mutex_unlock(&part->timeline.mutex);
mtx_unlock(&part->timeline.mutex);
VkResult result = radv_process_submissions(&processing_list);
@@ -7347,7 +7347,7 @@ static uint32_t radv_register_border_color(struct radv_device *device,
{
uint32_t slot;
pthread_mutex_lock(&device->border_color_data.mutex);
mtx_lock(&device->border_color_data.mutex);
for (slot = 0; slot < RADV_BORDER_COLOR_COUNT; slot++) {
if (!device->border_color_data.used[slot]) {
@@ -7361,7 +7361,7 @@ static uint32_t radv_register_border_color(struct radv_device *device,
}
}
pthread_mutex_unlock(&device->border_color_data.mutex);
mtx_unlock(&device->border_color_data.mutex);
return slot;
}
@@ -7369,11 +7369,11 @@ static uint32_t radv_register_border_color(struct radv_device *device,
static void radv_unregister_border_color(struct radv_device *device,
uint32_t slot)
{
pthread_mutex_lock(&device->border_color_data.mutex);
mtx_lock(&device->border_color_data.mutex);
device->border_color_data.used[slot] = false;
pthread_mutex_unlock(&device->border_color_data.mutex);
mtx_unlock(&device->border_color_data.mutex);
}
static void
src/amd/vulkan/radv_pipeline_cache.c
+4 -4
View File
@@ -49,7 +49,7 @@ radv_pipeline_cache_lock(struct radv_pipeline_cache *cache)
if (cache->flags & VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT)
return;
pthread_mutex_lock(&cache->mutex);
mtx_lock(&cache->mutex);
}
static void
@@ -58,7 +58,7 @@ radv_pipeline_cache_unlock(struct radv_pipeline_cache *cache)
if (cache->flags & VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT)
return;
pthread_mutex_unlock(&cache->mutex);
mtx_unlock(&cache->mutex);
}
void
@@ -66,7 +66,7 @@ radv_pipeline_cache_init(struct radv_pipeline_cache *cache,
struct radv_device *device)
{
cache->device = device;
pthread_mutex_init(&cache->mutex, NULL);
mtx_init(&cache->mutex, mtx_plain);
cache->flags = 0;
cache->modified = false;
@@ -98,7 +98,7 @@ radv_pipeline_cache_finish(struct radv_pipeline_cache *cache)
}
vk_free(&cache->alloc, cache->hash_table[i]);
}
pthread_mutex_destroy(&cache->mutex);
mtx_destroy(&cache->mutex);
free(cache->hash_table);
}
src/amd/vulkan/radv_private.h
+5 -6
View File
@@ -373,7 +373,7 @@ struct cache_entry;
struct radv_pipeline_cache {
struct vk_object_base base;
struct radv_device * device;
pthread_mutex_t mutex;
mtx_t mutex;
VkPipelineCacheCreateFlags flags;
uint32_t total_size;
@@ -727,9 +727,9 @@ struct radv_queue {
struct radeon_cmdbuf *continue_preamble_cs;
struct list_head pending_submissions;
pthread_mutex_t pending_mutex;
mtx_t pending_mutex;
pthread_mutex_t thread_mutex;
mtx_t thread_mutex;
struct u_cnd_monotonic thread_cond;
struct radv_deferred_queue_submission *thread_submission;
pthread_t submission_thread;
@@ -760,7 +760,7 @@ struct radv_device_border_color_data {
/* Mutex is required to guarantee vkCreateSampler thread safety
* given that we are writing to a buffer and checking color occupation */
pthread_mutex_t mutex;
mtx_t mutex;
};
struct radv_device {
@@ -2361,8 +2361,7 @@ struct radv_timeline_point {
};
struct radv_timeline {
/* Using a pthread mutex to be compatible with condition variables. */
pthread_mutex_t mutex;
mtx_t mutex;
uint64_t highest_signaled;
uint64_t highest_submitted;