void radv_destroy_semaphore_part(struct radv_device *device,
struct radv_semaphore_part *part);
-static VkResult
-radv_create_pthread_cond(pthread_cond_t *cond);
-
uint64_t radv_get_current_time(void)
{
- struct timespec tv;
- clock_gettime(CLOCK_MONOTONIC, &tv);
- return tv.tv_nsec + tv.tv_sec*1000000000ull;
+ return os_time_get_nano();
}
static uint64_t radv_get_absolute_timeout(uint64_t timeout)
pthread_mutex_init(&queue->pending_mutex, NULL);
pthread_mutex_init(&queue->thread_mutex, NULL);
- result = radv_create_pthread_cond(&queue->thread_cond);
- if (result != VK_SUCCESS)
+ if (u_cnd_monotonic_init(&queue->thread_cond)) {
+ result = VK_ERROR_INITIALIZATION_FAILED;
return vk_error(device->instance, result);
+ }
queue->cond_created = true;
return VK_SUCCESS;
if (queue->cond_created) {
if (queue->thread_running) {
p_atomic_set(&queue->thread_exit, true);
- pthread_cond_broadcast(&queue->thread_cond);
+ u_cnd_monotonic_broadcast(&queue->thread_cond);
pthread_join(queue->submission_thread, NULL);
}
- pthread_cond_destroy(&queue->thread_cond);
+ u_cnd_monotonic_destroy(&queue->thread_cond);
}
pthread_mutex_destroy(&queue->pending_mutex);
}
static VkResult
-radv_create_pthread_cond(pthread_cond_t *cond)
-{
- pthread_condattr_t condattr;
- if (pthread_condattr_init(&condattr)) {
- return VK_ERROR_INITIALIZATION_FAILED;
- }
-
- if (pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC)) {
- pthread_condattr_destroy(&condattr);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- if (pthread_cond_init(cond, &condattr)) {
- pthread_condattr_destroy(&condattr);
- return VK_ERROR_INITIALIZATION_FAILED;
- }
- pthread_condattr_destroy(&condattr);
- return VK_SUCCESS;
-}
-
-static VkResult
check_physical_device_features(VkPhysicalDevice physicalDevice,
const VkPhysicalDeviceFeatures *features)
{
device->mem_cache = radv_pipeline_cache_from_handle(pc);
- result = radv_create_pthread_cond(&device->timeline_cond);
- if (result != VK_SUCCESS)
+ if (u_cnd_monotonic_init(&device->timeline_cond)) {
+ result = VK_ERROR_INITIALIZATION_FAILED;
goto fail_mem_cache;
+ }
device->force_aniso =
MIN2(16, radv_get_int_debug_option("RADV_TEX_ANISO", -1));
radv_destroy_shader_slabs(device);
- pthread_cond_destroy(&device->timeline_cond);
+ u_cnd_monotonic_destroy(&device->timeline_cond);
radv_bo_list_finish(&device->bo_list);
free(device->thread_trace_trigger_file);
}
pthread_mutex_unlock(&submission->queue->pending_mutex);
- pthread_cond_broadcast(&submission->queue->device->timeline_cond);
+ u_cnd_monotonic_broadcast(&submission->queue->device->timeline_cond);
}
static VkResult
struct list_head processing_list;
VkResult result = VK_SUCCESS;
if (!submission) {
- pthread_cond_wait(&queue->thread_cond, &queue->thread_mutex);
+ u_cnd_monotonic_wait(&queue->thread_cond, &queue->thread_mutex);
continue;
}
pthread_mutex_unlock(&queue->thread_mutex);
queue->thread_submission = submission;
pthread_mutex_unlock(&queue->thread_mutex);
- pthread_cond_signal(&queue->thread_cond);
+ u_cnd_monotonic_signal(&queue->thread_cond);
return VK_SUCCESS;
}
pthread_mutex_lock(&queue->pending_mutex);
while (!list_is_empty(&queue->pending_submissions)) {
- pthread_cond_wait(&queue->device->timeline_cond, &queue->pending_mutex);
+ u_cnd_monotonic_wait(&queue->device->timeline_cond, &queue->pending_mutex);
}
pthread_mutex_unlock(&queue->pending_mutex);
struct timespec abstime;
timespec_from_nsec(&abstime, abs_timeout);
- pthread_cond_timedwait(&device->timeline_cond, &timeline->mutex, &abstime);
+ 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);
* processed before we wake the application. This way we
* ensure that any binary semaphores that are now unblocked
* are usable by the application. */
- pthread_cond_broadcast(&device->timeline_cond);
+ u_cnd_monotonic_broadcast(&device->timeline_cond);
return result;
}
--- /dev/null
+/**************************************************************************
+ *
+ * Copyright 2020 Lag Free Games, LLC
+ * All Rights Reserved.
+ *
+ * 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, sub license, 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 NON-INFRINGEMENT.
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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.
+ *
+ **************************************************************************/
+
+#ifndef CND_MONOTONIC_H
+#define CND_MONOTONIC_H
+
+#include "c11/threads.h"
+#include "util/os_time.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct u_cnd_monotonic
+{
+#ifdef _WIN32
+ CONDITION_VARIABLE condvar;
+#else
+ pthread_cond_t cond;
+#endif
+};
+
+static inline int
+u_cnd_monotonic_init(struct u_cnd_monotonic *cond)
+{
+ assert(cond != NULL);
+
+#ifdef _WIN32
+ InitializeConditionVariable(&cond->condvar);
+ return thrd_success;
+#else
+ int ret = thrd_error;
+ pthread_condattr_t condattr;
+ if (pthread_condattr_init(&condattr) == 0) {
+ if ((pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC) == 0) &&
+ (pthread_cond_init(&cond->cond, &condattr) == 0)) {
+ ret = thrd_success;
+ }
+
+ pthread_condattr_destroy(&condattr);
+ }
+
+ return ret;
+#endif
+}
+
+static inline void
+u_cnd_monotonic_destroy(struct u_cnd_monotonic *cond)
+{
+ assert(cond != NULL);
+
+#ifdef _WIN32
+ // Do nothing
+#else
+ pthread_cond_destroy(&cond->cond);
+#endif
+}
+
+static inline int
+u_cnd_monotonic_broadcast(struct u_cnd_monotonic *cond)
+{
+ assert(cond != NULL);
+
+#ifdef _WIN32
+ WakeAllConditionVariable(&cond->condvar);
+ return thrd_success;
+#else
+ return (pthread_cond_broadcast(&cond->cond) == 0) ? thrd_success : thrd_error;
+#endif
+}
+
+static inline int
+u_cnd_monotonic_signal(struct u_cnd_monotonic *cond)
+{
+ assert(cond != NULL);
+
+#ifdef _WIN32
+ WakeConditionVariable(&cond->condvar);
+ return thrd_success;
+#else
+ return (pthread_cond_signal(&cond->cond) == 0) ? thrd_success : thrd_error;
+#endif
+}
+
+static inline int
+u_cnd_monotonic_timedwait(struct u_cnd_monotonic *cond, mtx_t *mtx, const struct timespec *abs_time)
+{
+ assert(cond != NULL);
+ assert(mtx != NULL);
+ assert(abs_time != NULL);
+
+#ifdef _WIN32
+ const uint64_t future = (abs_time->tv_sec * 1000) + (abs_time->tv_nsec / 1000000);
+ const uint64_t now = os_time_get_nano() / 1000000;
+ const DWORD timeout = (future > now) ? (DWORD)(future - now) : 0;
+ if (SleepConditionVariableCS(&cond->condvar, mtx, timeout))
+ return thrd_success;
+ return (GetLastError() == ERROR_TIMEOUT) ? thrd_busy : thrd_error;
+#else
+ int rt = pthread_cond_timedwait(&cond->cond, mtx, abs_time);
+ if (rt == ETIMEDOUT)
+ return thrd_busy;
+ return (rt == 0) ? thrd_success : thrd_error;
+#endif
+}
+
+static inline int
+u_cnd_monotonic_wait(struct u_cnd_monotonic *cond, mtx_t *mtx)
+{
+ assert(cond != NULL);
+ assert(mtx != NULL);
+
+#ifdef _WIN32
+ SleepConditionVariableCS(&cond->condvar, mtx, INFINITE);
+ return thrd_success;
+#else
+ return (pthread_cond_wait(&cond->cond, mtx) == 0) ? thrd_success : thrd_error;
+#endif
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
projects / platform / upstream / mesa.git / commitdiff