util,radv: Cross-platform monotonic condition variable

cnd_t operates on REALTIME clock, and isn't suitable for MONOTONIC use.

Clone the API, and implement using a monotonic clock.

Reviewed-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/7138>

src/amd/vulkan/radv_device.c

@@ -86,14 +86,9 @@ static
 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;
+	return os_time_get_nano();
-	clock_gettime(CLOCK_MONOTONIC, &tv);
-	return tv.tv_nsec + tv.tv_sec*1000000000ull;
 }
 
 static uint64_t radv_get_absolute_timeout(uint64_t timeout)
@@ -2363,9 +2358,10 @@ radv_queue_init(struct radv_device *device, struct radv_queue *queue,
 	pthread_mutex_init(&queue->pending_mutex, NULL);
 
 	pthread_mutex_init(&queue->thread_mutex, NULL);
-	result = radv_create_pthread_cond(&queue->thread_cond);
+	if (u_cnd_monotonic_init(&queue->thread_cond)) {
-	if (result != VK_SUCCESS)
+		result = VK_ERROR_INITIALIZATION_FAILED;
 		return vk_error(device->instance, result);
+	}
 	queue->cond_created = true;
 
 	return VK_SUCCESS;
@@ -2378,11 +2374,11 @@ radv_queue_finish(struct radv_queue *queue)
 		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);
@@ -2560,26 +2556,6 @@ radv_device_init_dispatch(struct radv_device *device)
 	}
 }
 
-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)
@@ -2943,9 +2919,10 @@ VkResult radv_CreateDevice(
 
 	device->mem_cache = radv_pipeline_cache_from_handle(pc);
 
-	result = radv_create_pthread_cond(&device->timeline_cond);
+	if (u_cnd_monotonic_init(&device->timeline_cond)) {
-	if (result != VK_SUCCESS)
+		result = VK_ERROR_INITIALIZATION_FAILED;
 		goto fail_mem_cache;
+	}
 
 	device->force_aniso =
 		MIN2(16, radv_get_int_debug_option("RADV_TEX_ANISO", -1));
@@ -3022,7 +2999,7 @@ void radv_DestroyDevice(
 
 	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);
@@ -4503,7 +4480,7 @@ radv_queue_submission_update_queue(struct radv_deferred_queue_submission *submis
 	}
 	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
@@ -4745,7 +4722,7 @@ static void* radv_queue_submission_thread_run(void *q)
 		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);
@@ -4813,7 +4790,7 @@ radv_queue_trigger_submission(struct radv_deferred_queue_submission *submission,
 	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;
 }
 
@@ -4965,7 +4942,7 @@ VkResult radv_QueueWaitIdle(
 
 	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);
 
@@ -6136,7 +6113,7 @@ radv_timeline_wait(struct radv_device *device,
 		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);
@@ -6417,7 +6394,7 @@ radv_SignalSemaphore(VkDevice _device,
 		 * 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;
 	}

src/amd/vulkan/radv_private.h

@@ -46,6 +46,7 @@
 #include "c11/threads.h"
 #include <amdgpu.h>
 #include "compiler/shader_enums.h"
+#include "util/cnd_monotonic.h"
 #include "util/macros.h"
 #include "util/list.h"
 #include "util/rwlock.h"
@@ -730,7 +731,7 @@ struct radv_queue {
 	pthread_mutex_t pending_mutex;
 
 	pthread_mutex_t thread_mutex;
-	pthread_cond_t thread_cond;
+	struct u_cnd_monotonic thread_cond;
 	struct radv_deferred_queue_submission *thread_submission;
 	pthread_t submission_thread;
 	bool thread_exit;
@@ -837,7 +838,7 @@ struct radv_device {
 
 	/* Condition variable for legacy timelines, to notify waiters when a
 	 * new point gets submitted. */
-	pthread_cond_t timeline_cond;
+	struct u_cnd_monotonic timeline_cond;
 
 	/* Thread trace. */
 	struct radeon_cmdbuf *thread_trace_start_cs[2];

src/util/cnd_monotonic.h

@@ -0,0 +1,149 @@
+/**************************************************************************
+ *
+ * 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

src/util/meson.build

@@ -33,6 +33,7 @@ files_mesa_util = files(
   'blob.h',
   'build_id.c',
   'build_id.h',
+  'cnd_monotonic.h',
   'compiler.h',
   'crc32.c',
   'crc32.h',