Author: chaoren
Date: Mon Aug 17 19:27:08 2015
New Revision: 245262
URL: http://llvm.org/viewvc/llvm-project?rev=245262&view=rev
Log:
Revert part of "Convert all use of pthreads in tests to c++11 threads."
TestExprDoesntBlock started failing because deadlocks behave differently with
pthread_mutex and std::mutex.
This reverts part of commit r245234.
Added:
lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.c
Removed:
lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.cpp
Modified:
lldb/trunk/test/functionalities/expr-doesnt-deadlock/Makefile
lldb/trunk/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py
Modified: lldb/trunk/test/functionalities/expr-doesnt-deadlock/Makefile
URL:
http://llvm.org/viewvc/llvm-project/lldb/trunk/test/functionalities/expr-doesnt-deadlock/Makefile?rev=245262&r1=245261&r2=245262&view=diff
==============================================================================
--- lldb/trunk/test/functionalities/expr-doesnt-deadlock/Makefile (original)
+++ lldb/trunk/test/functionalities/expr-doesnt-deadlock/Makefile Mon Aug 17
19:27:08 2015
@@ -1,6 +1,6 @@
LEVEL = ../../make
-CXX_SOURCES := locking.cpp
+C_SOURCES := locking.c
ENABLE_THREADS := YES
include $(LEVEL)/Makefile.rules
Modified:
lldb/trunk/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py
URL:
http://llvm.org/viewvc/llvm-project/lldb/trunk/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py?rev=245262&r1=245261&r2=245262&view=diff
==============================================================================
--- lldb/trunk/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py
(original)
+++ lldb/trunk/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py
Mon Aug 17 19:27:08 2015
@@ -44,7 +44,7 @@ class ExprDoesntDeadlockTestCase(TestBas
# Now create a breakpoint at source line before call_me_to_get_lock
gets called.
- main_file_spec = lldb.SBFileSpec ("locking.cpp")
+ main_file_spec = lldb.SBFileSpec ("locking.c")
breakpoint = target.BreakpointCreateBySourceRegex('Break here',
main_file_spec)
if self.TraceOn():
print "breakpoint:", breakpoint
Added: lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.c
URL:
http://llvm.org/viewvc/llvm-project/lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.c?rev=245262&view=auto
==============================================================================
--- lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.c (added)
+++ lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.c Mon Aug 17
19:27:08 2015
@@ -0,0 +1,80 @@
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+
+pthread_mutex_t contended_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+pthread_mutex_t control_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t control_condition;
+
+pthread_mutex_t thread_started_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t thread_started_condition;
+
+// This function runs in a thread. The locking dance is to make sure that
+// by the time the main thread reaches the pthread_join below, this thread
+// has for sure acquired the contended_mutex. So then the call_me_to_get_lock
+// function will block trying to get the mutex, and only succeed once it
+// signals this thread, then lets it run to wake up from the cond_wait and
+// release the mutex.
+
+void *
+lock_acquirer_1 (void *input)
+{
+ pthread_mutex_lock (&contended_mutex);
+
+ // Grab this mutex, that will ensure that the main thread
+ // is in its cond_wait for it (since that's when it drops the mutex.
+
+ pthread_mutex_lock (&thread_started_mutex);
+ pthread_mutex_unlock(&thread_started_mutex);
+
+ // Now signal the main thread that it can continue, we have the contended
lock
+ // so the call to call_me_to_get_lock won't make any progress till this
+ // thread gets a chance to run.
+
+ pthread_mutex_lock (&control_mutex);
+
+ pthread_cond_signal (&thread_started_condition);
+
+ pthread_cond_wait (&control_condition, &control_mutex);
+
+ pthread_mutex_unlock (&contended_mutex);
+ return NULL;
+}
+
+int
+call_me_to_get_lock ()
+{
+ pthread_cond_signal (&control_condition);
+ pthread_mutex_lock (&contended_mutex);
+ return 567;
+}
+
+int main ()
+{
+ pthread_t thread_1;
+
+ pthread_cond_init (&control_condition, NULL);
+ pthread_cond_init (&thread_started_condition, NULL);
+
+ pthread_mutex_lock (&thread_started_mutex);
+
+ pthread_create (&thread_1, NULL, lock_acquirer_1, NULL);
+
+ pthread_cond_wait (&thread_started_condition, &thread_started_mutex);
+
+ pthread_mutex_lock (&control_mutex);
+ pthread_mutex_unlock (&control_mutex);
+
+ // Break here. At this point the other thread will have the contended_mutex,
+ // and be sitting in its cond_wait for the control condition. So there is
+ // no way that our by-hand calling of call_me_to_get_lock will proceed
+ // without running the first thread at least somewhat.
+
+ call_me_to_get_lock();
+ pthread_join (thread_1, NULL);
+
+ return 0;
+
+}
Removed: lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.cpp
URL:
http://llvm.org/viewvc/llvm-project/lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.cpp?rev=245261&view=auto
==============================================================================
--- lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.cpp (original)
+++ lldb/trunk/test/functionalities/expr-doesnt-deadlock/locking.cpp (removed)
@@ -1,80 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-
-#include <condition_variable>
-#include <mutex>
-#include <thread>
-
-std::mutex contended_mutex;
-std::mutex control_mutex;
-std::mutex thread_started_mutex;
-
-std::unique_lock<std::mutex> *contended_lock = nullptr;
-std::unique_lock<std::mutex> *control_lock = nullptr;
-std::unique_lock<std::mutex> *thread_started_lock = nullptr;
-
-std::condition_variable control_condition;
-std::condition_variable thread_started_condition;
-
-// This function runs in a thread. The locking dance is to make sure that
-// by the time the main thread reaches the pthread_join below, this thread
-// has for sure acquired the contended_mutex. So then the call_me_to_get_lock
-// function will block trying to get the mutex, and only succeed once it
-// signals this thread, then lets it run to wake up from the cond_wait and
-// release the mutex.
-
-void *
-lock_acquirer_1 ()
-{
- contended_lock->lock();
-
- // Grab this mutex, that will ensure that the main thread
- // is in its cond_wait for it (since that's when it drops the mutex.
- thread_started_lock->lock();
- thread_started_lock->unlock();
-
- // Now signal the main thread that it can continue, we have the contended
lock
- // so the call to call_me_to_get_lock won't make any progress till this
- // thread gets a chance to run.
- control_lock->lock();
-
- thread_started_condition.notify_all();
- control_condition.wait(*control_lock);
-
- return NULL;
-}
-
-int
-call_me_to_get_lock ()
-{
- control_condition.notify_all();
- contended_lock->lock();
- return 567;
-}
-
-int main ()
-{
- contended_lock = new std::unique_lock<std::mutex>(contended_mutex,
std::defer_lock);
- control_lock = new std::unique_lock<std::mutex>(control_mutex,
std::defer_lock);
- thread_started_lock = new
std::unique_lock<std::mutex>(thread_started_mutex, std::defer_lock);
-
- thread_started_lock->lock();
-
- std::thread thread_1(lock_acquirer_1);
-
- thread_started_condition.wait(*thread_started_lock);
-
- control_lock->lock();
- control_lock->unlock();
-
- // Break here. At this point the other thread will have the
contended_mutex,
- // and be sitting in its cond_wait for the control condition. So there is
- // no way that our by-hand calling of call_me_to_get_lock will proceed
- // without running the first thread at least somewhat.
-
- call_me_to_get_lock();
- thread_1.join();
-
- return 0;
-
-}
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
