[macOS] Threading: implement set_name

Macos has affinity requesting if using the policy for it, there is no dictating to the threads, it's only requesting.

Create a signal handler with a feedback flag and yield until we're sure the name is set (probably only needed for the unit_test because it doesn't give the mac thread scheduler a chance)

Author: Phatcat

src/libs/shared/shared/threading/Utility.cpp

@@ -19,6 +19,11 @@
 #include <cwchar>
 #elif defined TARGET_OS_MAC
 #include <pthread.h>
+#include <mach/mach.h>
+#include <mach/thread_policy.h>
+#include <signal.h>
+#include <atomic>
+#include <chrono>
 #elif defined __linux__ || defined __unix__
 #include <sched.h>
 #include <pthread.h>
@@ -92,53 +97,68 @@ Result set_name([[maybe_unused]] auto& handle, const char* name) {
 	FreeLibrary(lib);
 
 #elif defined TARGET_OS_MAC
-	auto ret = pthread_setname_np(name);
+	// On macOS, we use a signal-based mechanism to request the target thread to name itself.
+	pthread_t threadHandle = handle;
 
-	if(ret) {
-		throw std::runtime_error("Unable to set thread name, error code" + std::to_string(ret));
+	// Define a static flag (of type volatile sig_atomic_t) that the signal handler will set.
+	static volatile sig_atomic_t nameSetFlag = 0;
+	
+	static const char* desiredThreadName = name;
+
+	// Define the signal handler
+	const auto threadNameHandler = +[](int /*signum*/) -> void {
+		if (desiredThreadName != nullptr) {
+			pthread_setname_np(desiredThreadName);
+		}
+		nameSetFlag = 1; // Feed-back Flag
+	};
+
+	// Install the signal handler once for the process.
+	static std::atomic_flag handlerInstalled = ATOMIC_FLAG_INIT;
+	if (!handlerInstalled.test_and_set(std::memory_order_acquire)) {
+		signal(SIGUSR1, threadNameHandler);
+	}
+
+	// Send SIGUSR1 to the target thread so it runs our signal handler.
+	if (pthread_kill(threadHandle, SIGUSR1) != 0) {
+		return Result::unsupported;
 	}
+
+	// Wait until the flag is set. Instead of sleeping for a fixed time,
+	auto start = std::chrono::steady_clock::now();
+	while (nameSetFlag == 0) {std::this_thread::yield();} // yield to reduce CPU usage
+
+	return Result::ok;
+
 #elif defined __linux__ || defined __unix__
 	auto ret = pthread_setname_np(handle, name);
 
 	if(ret) {
 		throw std::runtime_error("Unable to set thread name, error code" + std::to_string(ret));
 	}
+
 #endif
 
 	return Result::ok;
 }
 
 Result set_name(std::jthread& thread, const char* name) {
-#ifndef TARGET_OS_MAC
 	const auto handle = thread.native_handle();
 	return set_name(handle, name);
-#else
-	#pragma message WARN("Setting thread names is not implemented for this platform. Implement it, please!")
-	return Result::unsupported;
-#endif
 }
 
 Result set_name(std::thread& thread, const char* name) {
-#ifndef TARGET_OS_MAC
 	const auto handle = thread.native_handle();
 	return set_name(handle, name);
-#else
-	#pragma message WARN("Setting thread names is not implemented for this platform. Implement it, please!")
-	return Result::unsupported;
-#endif
 }
 
 Result set_name(const char* name) {
 #ifdef _WIN32
 	auto handle = GetCurrentThread();
-	return set_name(handle, name);
-#elif defined __linux__ || defined __unix__ || defined TARGET_OS_MAC
-	auto handle = pthread_self();
-	return set_name(handle, name);
 #else
-	#pragma message WARN("Setting thread names is not implemented for this platform. Implement it, please!")
-	return Result::unsupported;
+	auto handle = pthread_self();
 #endif
+	return set_name(handle, name);
 }
 
 std::expected<std::wstring, Result> get_name(auto& thread) {
@@ -191,14 +211,10 @@ std::expected<std::wstring, Result> get_name(std::thread& thread) {
 std::expected<std::wstring, Result> get_name() {
 #ifdef _WIN32
 	auto handle = GetCurrentThread();
-	return get_name(handle);
-#elif defined __linux__ || defined __unix__ || TARGET_OS_MAC
-	auto handle = pthread_self();
-	return get_name(handle);
 #else
-	#pragma message WARN("Getting thread names is not implemented for this platform. Implement it, please!")
-	return std::unexpected(Result::unsupported);
+	auto handle = pthread_self();
 #endif
+	return get_name(handle);
 }
 
 /*
@@ -228,5 +244,4 @@ unsigned int hardware_concurrency() {
 	return hardware_concurrency(nullptr);
 }
 
-
 } // thread, ember