Fix hello_watchlocation test after r230691

[ki.stfu]

Summary

pthread_barrier_t isn't supported on OS X therefore it causes a compilation failure

1: test_hello_watchlocation_with_dwarf (TestWatchLocation.HelloWatchLocationTestCase)
   Test watching a location with '-x size' option. ...
os command: make clean EXE='test_hello_watchlocation_with_dwarf' CXX_SOURCES='main.cpp'; make MAKE_DSYM=NO ARCH=x86_64 CC="clang" EXE='test_hello_watchlocation_with_dwarf' CXX_SOURCES='main.cpp'
with pid: 90141
stdout: rm -f "test_hello_watchlocation_with_dwarf"  main.o main.d main.d.tmp
rm -f -r "test_hello_watchlocation_with_dwarf.dSYM"
clang++ -std=c++11 -g -O0 -arch x86_64   -I/Users/IliaK/p/llvm/tools/lldb/test/make/../../include   -c -o main.o main.cpp

stderr: main.cpp:21:1: error: unknown type name 'pthread_barrier_t'
pthread_barrier_t g_barrier;
^
1 error generated.
make: *** [main.o] Error 1

retcode: 2


ERROR

This patch uses pthread_mutex_t and pthread_cond_t which are standard.

This test works on OS X.

[ki.stfu]

the author created own version of this patch: http://reviews.llvm.org/D7933
This patch will not be committed.

[clayborg]

Looks good.

[clayborg]

We could also use the C++11 library to abstract us from the system instead of using pthread_ types and functions.

Should we use std::condition and std::mutex?

test/functionalities/watchpoint/hello_watchlocation/main.cpp

 #include <stdint.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 pthread_t g_thread_1 = NULL;
 pthread_t g_thread_2 = NULL;
 pthread_t g_thread_3 = NULL;
 
-pthread_barrier_t g_barrier;
+pthread_mutex_t g_mutex;
+pthread_cond_t g_cond;
+int g_count;
 
 char *g_char_ptr = NULL;
 
 void
+barrier_wait()
+{
+    pthread_mutex_lock(&g_mutex);
+    if (--g_count == 0)
+        pthread_cond_broadcast(&g_cond);
+    else
+        pthread_cond_wait(&g_cond, &g_mutex);
+    pthread_mutex_unlock(&g_mutex);
+}
+
+void
 do_bad_thing_with_location(char *char_ptr, char new_val)
 {
     unsigned what = new_val;
     printf("new value written to location(%p) = %u\n", char_ptr, what);
     *char_ptr = new_val;
 }
 
 uint32_t access_pool (uint32_t flag = 0);

 }
 
 void *
 thread_func (void *arg)
 {
     uint32_t thread_index = *((uint32_t *)arg);
     printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index);
 
-    pthread_barrier_wait(&g_barrier);
+    barrier_wait();
 
     uint32_t count = 0;
     uint32_t val;
     while (count++ < 15)
     {
         // random micro second sleep from zero to 3 seconds
         int usec = ::rand() % 3000000;
         printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec);
int main (int argc, char const *argv[])
     void *thread_result = NULL;
     uint32_t thread_index_1 = 1;
     uint32_t thread_index_2 = 2;
     uint32_t thread_index_3 = 3;
 
     g_char_ptr = (char *)malloc (1);
     *g_char_ptr = 0;
 
-    pthread_barrier_init(&g_barrier, NULL, 4);
+    pthread_mutex_init(&g_mutex, NULL);
+    pthread_cond_init(&g_cond, NULL);
+    g_count = 4;
 
     // Create 3 threads
     err = ::pthread_create (&g_thread_1, NULL, thread_func, &thread_index_1);
     err = ::pthread_create (&g_thread_2, NULL, thread_func, &thread_index_2);
     err = ::pthread_create (&g_thread_3, NULL, thread_func, &thread_index_3);
 
     printf ("Before turning all three threads loose...\n"); // Set break point at this line.
-    pthread_barrier_wait(&g_barrier);
+    barrier_wait();
 
     // Join all of our threads
     err = ::pthread_join (g_thread_1, &thread_result);
     err = ::pthread_join (g_thread_2, &thread_result);
     err = ::pthread_join (g_thread_3, &thread_result);
 
-    pthread_barrier_destroy(&g_barrier);
+    pthread_cond_destroy(&g_cond);
+    pthread_mutex_destroy(&g_mutex);
     free(g_char_ptr);
 
     return 0;
 }