Strange, I'll take a look tomorrow. Thanks for catching this On Mon, Aug 17, 2015 at 5:28 PM Chaoren Lin via lldb-commits < lldb-commits@lists.llvm.org> wrote:
> 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 >
_______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
