Some fixes for open breaks on MacOS and UBSan

[__simt__]

Summary

In this patch:

1. Reduced the net of dependencies when platform semaphores are disabled.
2. Respect the signed range of ptrdiff_t in tests.
3. Construct the aligned member for the barrier algorithm properly.

Testing on this code is pretty light at this stage.

[ldionne]

libcxx/src/barrier.cpp

40

Couldn't we use the aligned versions of operator new and delete here? I believe we could then get rid of the __state_t* __state pointer?

I was going to suggest some complicated solution that does explicit calls to operator new[](size_t, align_val_t), however after thinking about it harder I think simply compiling as C++17 would solve the problem, since the array would then be aligned properly.

@EricWF WDYT about building with C++17 enabled?

[ldionne]

But regardless, please ship this for now to unbreak the builders, this should be our top priority.

[ldionne]

This was landed as 621388468b5125f05d649262681676bed2faefe6

libcxx/include/__threading_support

 
 #if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
 # include <__external_threading>
 #elif !defined(_LIBCPP_HAS_NO_THREADS)
 
 #if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
 # include <pthread.h>
 # include <sched.h>
-// FIXME: On Apple, <semaphore.h> transitively includes <sys/param.h>, which
-//        is not well behaved because it defines several macros. This causes
-//        name collisions in some downstream projects. Instead, <sys/semaphore.h>
-//        gives us the declarations we need without the bad stuff.
-#ifdef __APPLE__
-# include <sys/semaphore.h>
-#else
-# include <semaphore.h>
-#endif
 # ifdef __APPLE__
 #  define _LIBCPP_NO_NATIVE_SEMAPHORES
 # endif
+# ifndef _LIBCPP_NO_NATIVE_SEMAPHORES
+# include <semaphore.h>
+# endif
 #elif defined(_LIBCPP_HAS_THREAD_API_C11)
 # include <threads.h>
 #endif
 
 #if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \
     defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) || \
     defined(_LIBCPP_HAS_THREAD_API_WIN32)
 #define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS

 #define _LIBCPP_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
 
 typedef pthread_mutex_t __libcpp_recursive_mutex_t;
 
 // Condition Variable
 typedef pthread_cond_t __libcpp_condvar_t;
 #define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER
 
+#ifndef _LIBCPP_NO_NATIVE_SEMAPHORES
 // Semaphore
 typedef sem_t __libcpp_semaphore_t;
-#define _LIBCPP_SEMAPHORE_MAX SEM_VALUE_MAX
+# define _LIBCPP_SEMAPHORE_MAX SEM_VALUE_MAX
+#endif
 
 // Execute once
 typedef pthread_once_t __libcpp_exec_once_flag;
 #define _LIBCPP_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT
 
 // Thread id
 typedef pthread_t __libcpp_thread_id;
 

 
 _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
 int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
                                __libcpp_timespec_t *__ts);
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);
 
+#ifndef _LIBCPP_NO_NATIVE_SEMAPHORES
+
 // Semaphore
 _LIBCPP_THREAD_ABI_VISIBILITY
 bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init);
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem);
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem);
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem);
 
 _LIBCPP_THREAD_ABI_VISIBILITY
 bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, chrono::nanoseconds const& __ns);
 
+#endif // _LIBCPP_NO_NATIVE_SEMAPHORES
+
 // Execute once
 _LIBCPP_THREAD_ABI_VISIBILITY
 int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
                           void (*init_routine)());
 
 // Thread id
 _LIBCPP_THREAD_ABI_VISIBILITY
 bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2);

libcxx/include/semaphore

typename conditional<(__least_max_value > 1 && __least_max_value <= _LIBCPP_SEMAPHORE_MAX),
                          __atomic_semaphore_base>::type;
 
 #else
 
 template<ptrdiff_t __least_max_value>
 using __semaphore_base =
     __atomic_semaphore_base;
 
+#define _LIBCPP_SEMAPHORE_MAX (numeric_limits<ptrdiff_t>::max())
+
 #endif //_LIBCPP_NO_NATIVE_SEMAPHORES
 
 template<ptrdiff_t __least_max_value = _LIBCPP_SEMAPHORE_MAX>
 class counting_semaphore
 {
     __semaphore_base<__least_max_value> __semaphore;
 
 public:

libcxx/src/barrier.cpp

 public:
     struct alignas(64) /* naturally-align the heap state */ __state_t
     {
         struct {
             __atomic_base<__barrier_phase_t> __phase = ATOMIC_VAR_INIT(0);
         } __tickets[64];
     };
 
-    ptrdiff_t&              __expected;
-    unique_ptr<__state_t[]> __state;
+    ptrdiff_t&         __expected;
+    unique_ptr<char[]> __state_allocation;
+    __state_t*         __state;
 
     _LIBCPP_HIDDEN
     __barrier_algorithm_base(ptrdiff_t& __expected)
-        : __expected(__expected), __state(new __barrier_algorithm_base::__state_t[(__expected + 1) >> 1])
+        : __expected(__expected)
     {
+        size_t const __count = (__expected + 1) >> 1;
+        size_t const __size = sizeof(__state_t) * __count;
+        size_t __allocation_size = __size + alignof(__state_t);
+        __state_allocation = unique_ptr<char[]>(new char[__allocation_size]);
+        void* __allocation = __state_allocation.get();
+        void* const __state_ = align(alignof(__state_t), __size, __allocation, __allocation_size);
+        __state = new (__state_) __barrier_algorithm_base::__state_t[__count];
     }
     _LIBCPP_HIDDEN
     bool __arrive(__barrier_phase_t __old_phase)
     {
         __barrier_phase_t const __half_step = __old_phase + 1,
                                 __full_step = __old_phase + 2;
         size_t __current_expected = __expected,
             __current = hash<thread::id>()(this_thread::get_id()) % ((__expected + 1) >> 1);

libcxx/test/std/thread/thread.semaphore/max.pass.cpp

 
 #include "test_macros.h"
 
 int main(int, char**)
 {
   static_assert(std::counting_semaphore<>::max() > 0, "");
   static_assert(std::counting_semaphore<1>::max() >= 1, "");
   static_assert(std::counting_semaphore<std::numeric_limits<int>::max()>::max() >= 1, "");
-  static_assert(std::counting_semaphore<std::numeric_limits<unsigned>::max()>::max() >= 1, "");
   static_assert(std::counting_semaphore<std::numeric_limits<ptrdiff_t>::max()>::max() >= 1, "");
   static_assert(std::counting_semaphore<1>::max() == std::binary_semaphore::max(), "");
   return 0;
 }