Fix macOS compatibility issues in realtime_tools package (#370)

---------

Signed-off-by: Dhruv Patel <[email protected]>
Co-authored-by: Sai Kishor Kothakota <[email protected]>
Co-authored-by: Christoph Fröhlich <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: 4 people

realtime_tools/CMakeLists.txt

@@ -45,7 +45,7 @@ target_include_directories(realtime_tools PUBLIC
   $<INSTALL_INTERFACE:include/realtime_tools>
 )
 target_link_libraries(realtime_tools PUBLIC rclcpp::rclcpp rclcpp_action::rclcpp_action rcpputils::rcpputils Threads::Threads Boost::boost)
-if(UNIX)
+if(UNIX AND NOT APPLE)
   target_link_libraries(realtime_tools PUBLIC cap)
 endif()
 
@@ -59,7 +59,7 @@ target_include_directories(thread_priority PUBLIC
   $<INSTALL_INTERFACE:include/realtime_tools>
 )
 target_link_libraries(thread_priority PUBLIC rclcpp::rclcpp rclcpp_action::rclcpp_action rcpputils::rcpputils Threads::Threads)
-if(UNIX)
+if(UNIX AND NOT APPLE)
   target_link_libraries(thread_priority PUBLIC cap)
 endif()
 
@@ -80,8 +80,9 @@ if(BUILD_TESTING)
   target_link_libraries(realtime_buffer_tests realtime_tools)
 
   ament_add_gmock(lock_free_queue_tests test/lock_free_queue_tests.cpp)
+
   target_link_libraries(lock_free_queue_tests realtime_tools Boost::boost)
-  if(UNIX)
+  if(UNIX AND NOT APPLE)
     target_link_libraries(lock_free_queue_tests atomic)
   endif()
 

realtime_tools/include/realtime_tools/mutex.hpp

@@ -52,12 +52,20 @@ struct recursive_mutex_type_t
 
 struct stalled_robustness_t
 {
+#if defined(__linux__)
   static constexpr int value = PTHREAD_MUTEX_STALLED;
+#else
+  static constexpr int value = 0;  // macOS, Windows, or other platforms fallback
+#endif
 };
 
 struct robust_robustness_t
 {
+#if defined(__linux__)
   static constexpr int value = PTHREAD_MUTEX_ROBUST;
+#else
+  static constexpr int value = 0;  // macOS, Windows, or other platforms fallback
+#endif
 };
 /**
  * @brief A class template that provides a pthread mutex with the priority inheritance protocol
@@ -109,10 +117,14 @@ class mutex
     }
 
     // Set the mutex attribute robustness to MutexRobustness
+    // On platforms like macOS, pthread_mutexattr_setrobust is not available,
+    // so skip this step
+#if defined(__linux__)
     const auto res_robust = pthread_mutexattr_setrobust(&attr, MutexRobustness::value);
     if (res_robust != 0) {
       throw std::system_error(res_robust, std::system_category(), "Failed to set mutex robustness");
     }
+#endif
 
     // Initialize the mutex with the attributes
     const auto res_init = pthread_mutex_init(&mutex_, &attr);
@@ -142,13 +154,20 @@ class mutex
       return;
     }
     if (res == EOWNERDEAD) {
+#if defined(__linux__)
       const auto res_consistent = pthread_mutex_consistent(&mutex_);
       if (res_consistent != 0) {
         throw std::runtime_error(
           std::string("Failed to make mutex consistent : ") + std::strerror(res_consistent));
       }
       std::cerr << "Mutex owner died, but the mutex is consistent now. This shouldn't happen!"
                 << std::endl;
+#else
+      // On platforms without pthread_mutex_consistent support, just log a warning
+      std::cerr
+        << "Mutex owner died, but pthread_mutex_consistent is not supported on this platform."
+        << std::endl;
+#endif
     } else if (res == EDEADLK) {
       throw std::system_error(res, std::system_category(), "Deadlock detected");
     } else {
@@ -174,13 +193,19 @@ class mutex
     if (res == EBUSY) {
       return false;
     } else if (res == EOWNERDEAD) {
+#if defined(__linux__)
       const auto res_consistent = pthread_mutex_consistent(&mutex_);
       if (res_consistent != 0) {
         throw std::runtime_error(
           std::string("Failed to make mutex consistent : ") + std::strerror(res_consistent));
       }
       std::cerr << "Mutex owner died, but the mutex is consistent now. This shouldn't happen!"
                 << std::endl;
+#else
+      std::cerr
+        << "Mutex owner died, but pthread_mutex_consistent is not supported on this platform."
+        << std::endl;
+#endif
     } else if (res == EDEADLK) {
       throw std::system_error(res, std::system_category(), "Deadlock detected");
     } else {

realtime_tools/src/realtime_helpers.cpp

@@ -32,10 +32,11 @@
 #include <windows.h>
 #else
 #include <sched.h>
+#if defined(__unix__)
 #include <sys/capability.h>
+#endif
 #include <sys/mman.h>
 #include <sys/utsname.h>
-
 #include <unistd.h>
 #endif
 
@@ -75,6 +76,20 @@ bool configure_sched_fifo(int priority)
 #ifdef _WIN32
   HANDLE thread = GetCurrentThread();
   return SetThreadPriority(thread, priority);
+#elif defined(__APPLE__)
+  // macOS implementation using pthread_setschedparam with SCHED_FIFO
+  pthread_t thread = pthread_self();
+  struct sched_param schedp;
+  memset(&schedp, 0, sizeof(schedp));
+  schedp.sched_priority = priority;
+
+  int policy = SCHED_FIFO;
+  if (pthread_setschedparam(thread, policy, &schedp) == 0) {
+    return true;
+  } else {
+    // Optionally log strerror(errno) for debugging
+    return false;
+  }
 #else
   struct sched_param schedp;
   memset(&schedp, 0, sizeof(schedp));
@@ -85,8 +100,8 @@ bool configure_sched_fifo(int priority)
 
 std::pair<bool, std::string> lock_memory()
 {
-#ifdef _WIN32
-  return {false, "Memory locking is not supported on Windows."};
+#if defined(_WIN32) || defined(__APPLE__)
+  return {false, "Memory locking is not supported on Windows or macOS."};
 #else
   auto is_capable = [](cap_value_t v) -> bool {
     bool rc = false;
@@ -136,8 +151,8 @@ std::pair<bool, std::string> set_thread_affinity(
   NATIVE_THREAD_HANDLE thread, const std::vector<int> & cores)
 {
   std::string message;
-#ifdef _WIN32
-  message = "Thread affinity is not supported on Windows.";
+#if defined(_WIN32) || defined(__APPLE__)
+  message = "Thread affinity is not supported on Windows or macOS.";
   return std::make_pair(false, message);
 #else
   auto set_affinity_result_message = [](int result, std::string & msg) -> bool {