[Lldb-commits] [lldb] r245262 - Revert part of "Convert all use of pthreads in tests to c++11 threads."
Zachary Turner via lldb-commits
lldb-commits at lists.llvm.org
Mon Aug 17 19:34:07 PDT 2015
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 at 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 at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/lldb-commits/attachments/20150818/3808142e/attachment-0001.html>
More information about the lldb-commits
mailing list