[lldb-dev] [Lldb-commits] [lldb] r277011 - Clean up vestigial remnants of locking primitives
Todd Fiala via lldb-dev
lldb-dev at lists.llvm.org
Thu Jul 28 10:58:49 PDT 2016
This just needed the files pulled out of the Xcode project.
On Thu, Jul 28, 2016 at 10:52 AM, Todd Fiala <todd.fiala at gmail.com> wrote:
>
> clang: error: no such file or directory: '/Volumes/Data/src/
> lldb-llvm.org/lldb/source/Host/common/Condition.cpp'
>
> clang: error: no input files
>
>
> $ find . -name Condition.cpp
>
> $
>
> On Thu, Jul 28, 2016 at 10:49 AM, Todd Fiala <todd.fiala at gmail.com> wrote:
>
>> Hi Saleem,
>>
>> It looks like you're missing Condition.cpp from your checkin @277011?
>> Can you add it?
>>
>> -Todd
>>
>> On Thu, Jul 28, 2016 at 10:32 AM, Saleem Abdulrasool via lldb-commits <
>> lldb-commits at lists.llvm.org> wrote:
>>
>>> Author: compnerd
>>> Date: Thu Jul 28 12:32:20 2016
>>> New Revision: 277011
>>>
>>> URL: http://llvm.org/viewvc/llvm-project?rev=277011&view=rev
>>> Log:
>>> Clean up vestigial remnants of locking primitives
>>>
>>> This finally removes the use of the Mutex and Condition classes. This is
>>> an
>>> intricate patch as the Mutex and Condition classes were tied together.
>>> Furthermore, many places had slightly differing uses of time values.
>>> Convert
>>> timeout values to relative everywhere to permit the use of
>>> std::chrono::duration, which is required for the use of
>>> std::condition_variable's timeout. Adjust all Condition and related Mutex
>>> classes over to std::{,recursive_}mutex and std::condition_variable.
>>>
>>> This change primarily comes at the cost of breaking the TracingMutex
>>> which was
>>> based around the Mutex class. It would be possible to write a wrapper to
>>> provide similar functionality, but that is beyond the scope of this
>>> change.
>>>
>>> Removed:
>>> lldb/trunk/include/lldb/Host/Condition.h
>>> lldb/trunk/include/lldb/Host/Mutex.h
>>> lldb/trunk/source/Host/common/Condition.cpp
>>> lldb/trunk/source/Host/common/Mutex.cpp
>>> lldb/trunk/source/Host/windows/Condition.cpp
>>> lldb/trunk/source/Host/windows/Mutex.cpp
>>> Modified:
>>> lldb/trunk/include/lldb/Core/Event.h
>>> lldb/trunk/include/lldb/Core/Listener.h
>>> lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h
>>> lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h
>>> lldb/trunk/include/lldb/Host/Editline.h
>>> lldb/trunk/include/lldb/Host/Predicate.h
>>> lldb/trunk/include/lldb/Host/ProcessRunLock.h
>>> lldb/trunk/include/lldb/Target/Process.h
>>> lldb/trunk/source/API/SBListener.cpp
>>> lldb/trunk/source/Core/Communication.cpp
>>> lldb/trunk/source/Core/Debugger.cpp
>>> lldb/trunk/source/Core/Listener.cpp
>>> lldb/trunk/source/Host/CMakeLists.txt
>>> lldb/trunk/source/Host/common/Host.cpp
>>> lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp
>>>
>>> lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h
>>> lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp
>>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
>>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h
>>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
>>>
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
>>>
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
>>>
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
>>>
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
>>> lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
>>> lldb/trunk/source/Target/Process.cpp
>>> lldb/trunk/source/Target/Target.cpp
>>>
>>> Modified: lldb/trunk/include/lldb/Core/Event.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/Event.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Core/Event.h (original)
>>> +++ lldb/trunk/include/lldb/Core/Event.h Thu Jul 28 12:32:20 2016
>>> @@ -12,6 +12,7 @@
>>>
>>> // C Includes
>>> // C++ Includes
>>> +#include <chrono>
>>> #include <memory>
>>> #include <string>
>>>
>>> @@ -141,7 +142,8 @@ public:
>>> }
>>>
>>> bool
>>> - WaitForEventReceived (const TimeValue *abstime = nullptr, bool
>>> *timed_out = nullptr)
>>> + WaitForEventReceived(const std::chrono::microseconds &abstime =
>>> std::chrono::microseconds(0),
>>> + bool *timed_out = nullptr)
>>> {
>>> return m_predicate.WaitForValueEqualTo(true, abstime,
>>> timed_out);
>>> }
>>>
>>> Modified: lldb/trunk/include/lldb/Core/Listener.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/Listener.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Core/Listener.h (original)
>>> +++ lldb/trunk/include/lldb/Core/Listener.h Thu Jul 28 12:32:20 2016
>>> @@ -12,6 +12,7 @@
>>>
>>> // C Includes
>>> // C++ Includes
>>> +#include <chrono>
>>> #include <list>
>>> #include <map>
>>> #include <mutex>
>>> @@ -21,8 +22,6 @@
>>> // Other libraries and framework includes
>>> // Project includes
>>> #include "lldb/lldb-private.h"
>>> -#include "lldb/Core/Broadcaster.h"
>>> -#include "lldb/Host/Condition.h"
>>> #include "lldb/Core/Event.h"
>>>
>>> namespace lldb_private {
>>> @@ -87,19 +86,15 @@ public:
>>>
>>> // Returns true if an event was received, false if we timed out.
>>> bool
>>> - WaitForEvent (const TimeValue *timeout,
>>> - lldb::EventSP &event_sp);
>>> + WaitForEvent(const std::chrono::microseconds &timeout,
>>> lldb::EventSP &event_sp);
>>>
>>> bool
>>> - WaitForEventForBroadcaster (const TimeValue *timeout,
>>> - Broadcaster *broadcaster,
>>> - lldb::EventSP &event_sp);
>>> + WaitForEventForBroadcaster(const std::chrono::microseconds
>>> &timeout, Broadcaster *broadcaster,
>>> + lldb::EventSP &event_sp);
>>>
>>> bool
>>> - WaitForEventForBroadcasterWithType (const TimeValue *timeout,
>>> - Broadcaster *broadcaster,
>>> - uint32_t event_type_mask,
>>> - lldb::EventSP &event_sp);
>>> + WaitForEventForBroadcasterWithType(const std::chrono::microseconds
>>> &timeout, Broadcaster *broadcaster,
>>> + uint32_t event_type_mask,
>>> lldb::EventSP &event_sp);
>>>
>>> Event *
>>> PeekAtNextEvent ();
>>> @@ -151,13 +146,10 @@ private:
>>> typedef std::vector<lldb::BroadcasterManagerWP>
>>> broadcaster_manager_collection;
>>>
>>> bool
>>> - FindNextEventInternal(Mutex::Locker& lock,
>>> + FindNextEventInternal(std::unique_lock<std::mutex> &lock,
>>> Broadcaster *broadcaster, // nullptr for
>>> any broadcaster
>>> const ConstString *sources, // nullptr for
>>> any event
>>> - uint32_t num_sources,
>>> - uint32_t event_type_mask,
>>> - lldb::EventSP &event_sp,
>>> - bool remove);
>>> + uint32_t num_sources, uint32_t
>>> event_type_mask, lldb::EventSP &event_sp, bool remove);
>>>
>>> bool
>>> GetNextEventInternal(Broadcaster *broadcaster, // nullptr for any
>>> broadcaster
>>> @@ -167,19 +159,17 @@ private:
>>> lldb::EventSP &event_sp);
>>>
>>> bool
>>> - WaitForEventsInternal(const TimeValue *timeout,
>>> + WaitForEventsInternal(const std::chrono::microseconds &timeout,
>>> Broadcaster *broadcaster, // nullptr for
>>> any broadcaster
>>> const ConstString *sources, // nullptr for
>>> any event
>>> - uint32_t num_sources,
>>> - uint32_t event_type_mask,
>>> - lldb::EventSP &event_sp);
>>> + uint32_t num_sources, uint32_t
>>> event_type_mask, lldb::EventSP &event_sp);
>>>
>>> std::string m_name;
>>> broadcaster_collection m_broadcasters;
>>> std::recursive_mutex m_broadcasters_mutex; // Protects
>>> m_broadcasters
>>> event_collection m_events;
>>> - Mutex m_events_mutex; // Protects m_broadcasters and m_events
>>> - Condition m_events_condition;
>>> + std::mutex m_events_mutex; // Protects m_broadcasters and m_events
>>> + std::condition_variable m_events_condition;
>>> broadcaster_manager_collection m_broadcaster_managers;
>>>
>>> void
>>>
>>> Modified: lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h (original)
>>> +++ lldb/trunk/include/lldb/Core/ThreadSafeDenseMap.h Thu Jul 28
>>> 12:32:20 2016
>>> @@ -12,46 +12,41 @@
>>>
>>> // C Includes
>>> // C++ Includes
>>> +#include <mutex>
>>>
>>> // Other libraries and framework includes
>>> #include "llvm/ADT/DenseMap.h"
>>>
>>> // Project includes
>>> -#include "lldb/Host/Mutex.h"
>>>
>>> namespace lldb_private {
>>>
>>> -template <typename _KeyType, typename _ValueType>
>>> +template <typename _KeyType, typename _ValueType, typename _MutexType =
>>> std::mutex>
>>> class ThreadSafeDenseMap
>>> {
>>> public:
>>> typedef llvm::DenseMap<_KeyType,_ValueType> LLVMMapType;
>>> -
>>> - ThreadSafeDenseMap(unsigned map_initial_capacity = 0,
>>> - Mutex::Type mutex_type =
>>> Mutex::eMutexTypeNormal) :
>>> - m_map(map_initial_capacity),
>>> - m_mutex(mutex_type)
>>> - {
>>> - }
>>> -
>>> +
>>> + ThreadSafeDenseMap(unsigned map_initial_capacity = 0) :
>>> m_map(map_initial_capacity), m_mutex() {}
>>> +
>>> void
>>> Insert (_KeyType k, _ValueType v)
>>> {
>>> - Mutex::Locker locker(m_mutex);
>>> + std::lock_guard<_MutexType> guard(m_mutex);
>>> m_map.insert(std::make_pair(k,v));
>>> }
>>>
>>> void
>>> Erase (_KeyType k)
>>> {
>>> - Mutex::Locker locker(m_mutex);
>>> + std::lock_guard<_MutexType> guard(m_mutex);
>>> m_map.erase(k);
>>> }
>>>
>>> _ValueType
>>> Lookup (_KeyType k)
>>> {
>>> - Mutex::Locker locker(m_mutex);
>>> + std::lock_guard<_MutexType> guard(m_mutex);
>>> return m_map.lookup(k);
>>> }
>>>
>>> @@ -59,7 +54,7 @@ public:
>>> Lookup (_KeyType k,
>>> _ValueType& v)
>>> {
>>> - Mutex::Locker locker(m_mutex);
>>> + std::lock_guard<_MutexType> guard(m_mutex);
>>> auto iter = m_map.find(k),
>>> end = m_map.end();
>>> if (iter == end)
>>> @@ -71,13 +66,13 @@ public:
>>> void
>>> Clear ()
>>> {
>>> - Mutex::Locker locker(m_mutex);
>>> + std::lock_guard<_MutexType> guard(m_mutex);
>>> m_map.clear();
>>> }
>>>
>>> protected:
>>> LLVMMapType m_map;
>>> - Mutex m_mutex;
>>> + _MutexType m_mutex;
>>> };
>>>
>>> } // namespace lldb_private
>>>
>>> Modified: lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h (original)
>>> +++ lldb/trunk/include/lldb/Core/ThreadSafeDenseSet.h Thu Jul 28
>>> 12:32:20 2016
>>> @@ -12,61 +12,56 @@
>>>
>>> // C Includes
>>> // C++ Includes
>>> +#include <mutex>
>>>
>>> // Other libraries and framework includes
>>> #include "llvm/ADT/DenseSet.h"
>>>
>>> // Project includes
>>> -#include "lldb/Host/Mutex.h"
>>>
>>> namespace lldb_private {
>>> -
>>> - template <typename _ElementType>
>>> - class ThreadSafeDenseSet
>>> +
>>> +template <typename _ElementType, typename _MutexType = std::mutex>
>>> +class ThreadSafeDenseSet
>>> +{
>>> +public:
>>> + typedef llvm::DenseSet<_ElementType> LLVMSetType;
>>> +
>>> + ThreadSafeDenseSet(unsigned set_initial_capacity = 0) :
>>> m_set(set_initial_capacity), m_mutex() {}
>>> +
>>> + void
>>> + Insert(_ElementType e)
>>> {
>>> - public:
>>> - typedef llvm::DenseSet<_ElementType> LLVMSetType;
>>> -
>>> - ThreadSafeDenseSet(unsigned set_initial_capacity = 0,
>>> - Mutex::Type mutex_type =
>>> Mutex::eMutexTypeNormal) :
>>> - m_set(set_initial_capacity),
>>> - m_mutex(mutex_type)
>>> - {
>>> - }
>>> -
>>> - void
>>> - Insert (_ElementType e)
>>> - {
>>> - Mutex::Locker locker(m_mutex);
>>> - m_set.insert(e);
>>> - }
>>> -
>>> - void
>>> - Erase (_ElementType e)
>>> - {
>>> - Mutex::Locker locker(m_mutex);
>>> - m_set.erase(e);
>>> - }
>>> -
>>> - bool
>>> - Lookup (_ElementType e)
>>> - {
>>> - Mutex::Locker locker(m_mutex);
>>> - return (m_set.count(e) > 0);
>>> - }
>>> -
>>> - void
>>> - Clear ()
>>> - {
>>> - Mutex::Locker locker(m_mutex);
>>> - m_set.clear();
>>> - }
>>> -
>>> - protected:
>>> - LLVMSetType m_set;
>>> - Mutex m_mutex;
>>> - };
>>> -
>>> + std::lock_guard<_MutexType> guard(m_mutex);
>>> + m_set.insert(e);
>>> + }
>>> +
>>> + void
>>> + Erase(_ElementType e)
>>> + {
>>> + std::lock_guard<_MutexType> guard(m_mutex);
>>> + m_set.erase(e);
>>> + }
>>> +
>>> + bool
>>> + Lookup(_ElementType e)
>>> + {
>>> + std::lock_guard<_MutexType> guard(m_mutex);
>>> + return (m_set.count(e) > 0);
>>> + }
>>> +
>>> + void
>>> + Clear()
>>> + {
>>> + stds::lock_guard<_MutexType> guard(m_mutex);
>>> + m_set.clear();
>>> + }
>>> +
>>> +protected:
>>> + LLVMSetType m_set;
>>> + _MutexType m_mutex;
>>> +};
>>> +
>>> } // namespace lldb_private
>>>
>>> #endif // liblldb_ThreadSafeDenseSet_h_
>>>
>>> Removed: lldb/trunk/include/lldb/Host/Condition.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/Condition.h?rev=277010&view=auto
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Host/Condition.h (original)
>>> +++ lldb/trunk/include/lldb/Host/Condition.h (removed)
>>> @@ -1,123 +0,0 @@
>>> -//===-- Condition.h ---------------------------------------------*- C++
>>> -*-===//
>>> -//
>>> -// The LLVM Compiler Infrastructure
>>> -//
>>> -// This file is distributed under the University of Illinois Open Source
>>> -// License. See LICENSE.TXT for details.
>>> -//
>>>
>>> -//===----------------------------------------------------------------------===//
>>> -
>>> -#ifndef liblldb_Condition_h_
>>> -#define liblldb_Condition_h_
>>> -
>>> -// C Includes
>>> -// C++ Includes
>>> -// Other libraries and framework includes
>>> -// Project includes
>>> -#include "lldb/lldb-types.h"
>>> -#include "lldb/Host/Mutex.h"
>>> -
>>> -namespace lldb_private {
>>> -
>>> -class TimeValue;
>>> -
>>> -//----------------------------------------------------------------------
>>> -/// @class Condition Condition.h "lldb/Host/Condition.h"
>>> -/// @brief A C++ wrapper class for pthread condition variables.
>>> -///
>>> -/// A class that wraps up a pthread condition (pthread_cond_t). The
>>> -/// class will create a pthread condition when an instance is
>>> -/// constructed, and destroy it when it is destructed. It also provides
>>> -/// access to the standard pthread condition calls.
>>> -//----------------------------------------------------------------------
>>> -class Condition
>>> -{
>>> -public:
>>> - //------------------------------------------------------------------
>>> - /// Default constructor
>>> - ///
>>> - /// The default constructor will initialize a new pthread condition
>>> - /// and maintain the condition in the object state.
>>> - //------------------------------------------------------------------
>>> - Condition ();
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Destructor
>>> - ///
>>> - /// Destroys the pthread condition that the object owns.
>>> - //------------------------------------------------------------------
>>> - ~Condition ();
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Unblock all threads waiting for a condition variable
>>> - ///
>>> - /// @return
>>> - /// The return value from \c pthread_cond_broadcast()
>>> - //------------------------------------------------------------------
>>> - int
>>> - Broadcast ();
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Unblocks one thread waiting for the condition variable
>>> - ///
>>> - /// @return
>>> - /// The return value from \c pthread_cond_signal()
>>> - //------------------------------------------------------------------
>>> - int
>>> - Signal ();
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Wait for the condition variable to be signaled.
>>> - ///
>>> - /// The Wait() function atomically blocks the current thread
>>> - /// waiting on this object's condition variable, and unblocks
>>> - /// \a mutex. The waiting thread unblocks only after another thread
>>> - /// signals or broadcasts this object's condition variable.
>>> - ///
>>> - /// If \a abstime is non-nullptr, this function will return when the
>>> - /// system time reaches the time specified in \a abstime if the
>>> - /// condition variable doesn't get unblocked. If \a abstime is
>>> nullptr
>>> - /// this function will wait for an infinite amount of time for the
>>> - /// condition variable to be unblocked.
>>> - ///
>>> - /// The current thread re-acquires the lock on \a mutex following
>>> - /// the wait.
>>> - ///
>>> - /// @param[in] mutex
>>> - /// The mutex to use in the \c pthread_cond_timedwait() or
>>> - /// \c pthread_cond_wait() calls.
>>> - ///
>>> - /// @param[in] abstime
>>> - /// An absolute time at which to stop waiting if non-nullptr,
>>> else
>>> - /// wait an infinite amount of time for the condition variable
>>> - /// toget signaled.
>>> - ///
>>> - /// @param[out] timed_out
>>> - /// If not nullptr, will be set to true if the wait timed out,
>>> and
>>> - // false otherwise.
>>> - ///
>>> - /// @see Condition::Broadcast()
>>> - /// @see Condition::Signal()
>>> - //------------------------------------------------------------------
>>> - int
>>> - Wait(Mutex &mutex, const TimeValue *abstime = nullptr, bool
>>> *timed_out = nullptr);
>>> -
>>> -protected:
>>> - //------------------------------------------------------------------
>>> - // Member variables
>>> - //------------------------------------------------------------------
>>> - lldb::condition_t m_condition; ///< The condition variable.
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Get accessor to the pthread condition object.
>>> - ///
>>> - /// @return
>>> - /// A pointer to the condition variable owned by this object.
>>> - //------------------------------------------------------------------
>>> - lldb::condition_t *
>>> - GetCondition ();
>>> -};
>>> -
>>> -} // namespace lldb_private
>>> -
>>> -#endif // liblldb_Condition_h_
>>>
>>> Modified: lldb/trunk/include/lldb/Host/Editline.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/Editline.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Host/Editline.h (original)
>>> +++ lldb/trunk/include/lldb/Host/Editline.h Thu Jul 28 12:32:20 2016
>>> @@ -54,7 +54,6 @@
>>> #include <string>
>>> #include <vector>
>>>
>>> -#include "lldb/Host/Condition.h"
>>> #include "lldb/Host/ConnectionFileDescriptor.h"
>>> #include "lldb/Host/FileSpec.h"
>>> #include "lldb/Host/Predicate.h"
>>>
>>> Removed: lldb/trunk/include/lldb/Host/Mutex.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/Mutex.h?rev=277010&view=auto
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Host/Mutex.h (original)
>>> +++ lldb/trunk/include/lldb/Host/Mutex.h (removed)
>>> @@ -1,313 +0,0 @@
>>> -//===-- Mutex.h -------------------------------------------------*- C++
>>> -*-===//
>>> -//
>>> -// The LLVM Compiler Infrastructure
>>> -//
>>> -// This file is distributed under the University of Illinois Open Source
>>> -// License. See LICENSE.TXT for details.
>>> -//
>>>
>>> -//===----------------------------------------------------------------------===//
>>> -
>>> -#ifndef liblldb_Mutex_h_
>>> -#define liblldb_Mutex_h_
>>> -
>>> -// C Includes
>>> -// C++ Includes
>>> -#ifdef LLDB_CONFIGURATION_DEBUG
>>> -#include <string>
>>> -#endif
>>> -
>>> -// Other libraries and framework includes
>>> -// Project includes
>>> -#include "lldb/lldb-types.h"
>>> -
>>> -namespace lldb_private {
>>> -
>>> -//----------------------------------------------------------------------
>>> -/// @class Mutex Mutex.h "lldb/Host/Mutex.h"
>>> -/// @brief A C++ wrapper class for pthread mutexes.
>>> -//----------------------------------------------------------------------
>>> -class Mutex
>>> -{
>>> -public:
>>> - friend class Locker;
>>> - friend class Condition;
>>> -
>>> - enum Type
>>> - {
>>> - eMutexTypeNormal, ///< Mutex that can't recursively
>>> entered by the same thread
>>> - eMutexTypeRecursive ///< Mutex can be recursively entered
>>> by the same thread
>>> - };
>>> -
>>> - //------------------------------------------------------------------
>>> - /// @class Mutex::Locker
>>> - ///
>>> - /// A scoped locking class that allows a variety of pthread mutex
>>> - /// objects to have a mutex locked when an Mutex::Locker
>>> - /// object is created, and unlocked when it goes out of scope or
>>> - /// when the Mutex::Locker::Reset(pthread_mutex_t *)
>>> - /// is called. This provides an exception safe way to lock a mutex
>>> - /// in a scope.
>>> - //------------------------------------------------------------------
>>> - class Locker
>>> - {
>>> - public:
>>> - //--------------------------------------------------------------
>>> - /// Default constructor.
>>> - ///
>>> - /// This will create a scoped mutex locking object that doesn't
>>> - /// have a mutex to lock. One will need to be provided using the
>>> - /// Mutex::Locker::Reset(pthread_mutex_t *) method.
>>> - ///
>>> - /// @see Mutex::Locker::Reset(pthread_mutex_t *)
>>> - //--------------------------------------------------------------
>>> - Locker();
>>> -
>>> - //--------------------------------------------------------------
>>> - /// Constructor with a Mutex object.
>>> - ///
>>> - /// This will create a scoped mutex locking object that extracts
>>> - /// the mutex owned by \a m and locks it.
>>> - ///
>>> - /// @param[in] m
>>> - /// An instance of a Mutex object that contains a
>>> - /// valid mutex object.
>>> - //--------------------------------------------------------------
>>> - Locker(Mutex& m);
>>> -
>>> - //--------------------------------------------------------------
>>> - /// Constructor with a Mutex object pointer.
>>> - ///
>>> - /// This will create a scoped mutex locking object that extracts
>>> - /// the mutex owned by a m and locks it.
>>> - ///
>>> - /// @param[in] m
>>> - /// A pointer to instance of a Mutex object that
>>> - /// contains a valid mutex object.
>>> - //--------------------------------------------------------------
>>> - Locker(Mutex* m);
>>> -
>>> - //--------------------------------------------------------------
>>> - /// Destructor
>>> - ///
>>> - /// Unlocks any valid pthread_mutex_t that this object may
>>> - /// contain.
>>> - //--------------------------------------------------------------
>>> - ~Locker();
>>> -
>>> - //--------------------------------------------------------------
>>> - /// Change the contained mutex.
>>> - ///
>>> - /// Unlock the current mutex in this object (if it contains a
>>> - /// valid mutex) and lock the new \a mutex object if it is
>>> - /// non-nullptr.
>>> - //--------------------------------------------------------------
>>> - void
>>> - Lock (Mutex &mutex);
>>> -
>>> - void
>>> - Lock (Mutex *mutex)
>>> - {
>>> - if (mutex)
>>> - Lock(*mutex);
>>> - }
>>> -
>>> - //--------------------------------------------------------------
>>> - /// Change the contained mutex only if the mutex can be locked.
>>> - ///
>>> - /// Unlock the current mutex in this object (if it contains a
>>> - /// valid mutex) and try to lock \a mutex. If \a mutex can be
>>> - /// locked this object will take ownership of the lock and will
>>> - /// unlock it when it goes out of scope or Reset or TryLock are
>>> - /// called again. If the mutex is already locked, this object
>>> - /// will not take ownership of the mutex.
>>> - ///
>>> - /// @return
>>> - /// Returns \b true if the lock was acquired and the this
>>> - /// object will unlock the mutex when it goes out of scope,
>>> - /// returns \b false otherwise.
>>> - //--------------------------------------------------------------
>>> - bool
>>> - TryLock(Mutex &mutex, const char *failure_message = nullptr);
>>> -
>>> - bool
>>> - TryLock(Mutex *mutex, const char *failure_message = nullptr)
>>> - {
>>> - if (mutex)
>>> - return TryLock(*mutex, failure_message);
>>> - else
>>> - return false;
>>> - }
>>> -
>>> - void
>>> - Unlock ();
>>> -
>>> - protected:
>>> - //--------------------------------------------------------------
>>> - /// Member variables
>>> - //--------------------------------------------------------------
>>> - Mutex *m_mutex_ptr;
>>> -
>>> - private:
>>> - Locker(const Locker&);
>>> - const Locker& operator=(const Locker&);
>>> - };
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Default constructor.
>>> - ///
>>> - /// Creates a pthread mutex with no attributes.
>>> - //------------------------------------------------------------------
>>> - Mutex();
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Default constructor.
>>> - ///
>>> - /// Creates a pthread mutex with \a type as the mutex type.
>>> - /// Valid values for \a type include:
>>> - /// @li Mutex::Type::eMutexTypeNormal
>>> - /// @li Mutex::Type::eMutexTypeRecursive
>>> - ///
>>> - /// @param[in] type
>>> - /// The type of the mutex.
>>> - ///
>>> - /// @see ::pthread_mutexattr_settype()
>>> - //------------------------------------------------------------------
>>> - Mutex(Mutex::Type type);
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Destructor.
>>> - ///
>>> - /// Destroys the mutex owned by this object.
>>> - //------------------------------------------------------------------
>>> -#ifdef LLDB_CONFIGURATION_DEBUG
>>> - virtual
>>> -#endif
>>> - ~Mutex();
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Lock the mutex.
>>> - ///
>>> - /// Locks the mutex owned by this object. If the mutex is already
>>> - /// locked, the calling thread will block until the mutex becomes
>>> - /// available.
>>> - ///
>>> - /// @return
>>> - /// The error code from \c pthread_mutex_lock().
>>> - //------------------------------------------------------------------
>>> -#ifdef LLDB_CONFIGURATION_DEBUG
>>> - virtual
>>> -#endif
>>> - int
>>> - Lock();
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Try to lock the mutex.
>>> - ///
>>> - /// Attempts to lock the mutex owned by this object without
>>> blocking.
>>> - /// If the mutex is already locked, TryLock() will not block waiting
>>> - /// for the mutex, but will return an error condition.
>>> - ///
>>> - /// @return
>>> - /// The error code from \c pthread_mutex_trylock().
>>> - //------------------------------------------------------------------
>>> -#ifdef LLDB_CONFIGURATION_DEBUG
>>> - virtual
>>> -#endif
>>> - int
>>> - TryLock(const char *failure_message = nullptr);
>>> -
>>> - //------------------------------------------------------------------
>>> - /// Unlock the mutex.
>>> - ///
>>> - /// If the current thread holds the lock on the owned mutex, then
>>> - /// Unlock() will unlock the mutex. Calling Unlock() on this object
>>> - /// when the calling thread does not hold the lock will result in
>>> - /// undefined behavior.
>>> - ///
>>> - /// @return
>>> - /// The error code from \c pthread_mutex_unlock().
>>> - //------------------------------------------------------------------
>>> -#ifdef LLDB_CONFIGURATION_DEBUG
>>> - virtual
>>> -#endif
>>> - int
>>> - Unlock();
>>> -
>>> -protected:
>>> - //------------------------------------------------------------------
>>> - // Member variables
>>> - //------------------------------------------------------------------
>>> - // TODO: Hide the mutex in the implementation file in case we ever
>>> need to port to an
>>> - // architecture that doesn't have pthread mutexes.
>>> - lldb::mutex_t m_mutex; ///< The OS mutex object.
>>> -
>>> -private:
>>> - //------------------------------------------------------------------
>>> - /// Mutex get accessor.
>>> - ///
>>> - /// @return
>>> - /// A pointer to the pthread mutex object owned by this object.
>>> - //------------------------------------------------------------------
>>> - lldb::mutex_t *
>>> - GetMutex();
>>> -
>>> - Mutex(const Mutex&);
>>> - const Mutex& operator=(const Mutex&);
>>> -};
>>> -
>>> -#ifdef LLDB_CONFIGURATION_DEBUG
>>> -class TrackingMutex : public Mutex
>>> -{
>>> -public:
>>> - TrackingMutex() : Mutex() {}
>>> - TrackingMutex(Mutex::Type type) : Mutex (type) {}
>>> -
>>> - virtual
>>> - ~TrackingMutex() = default;
>>> -
>>> - virtual int
>>> - Unlock ();
>>> -
>>> - virtual int
>>> - TryLock(const char *failure_message = nullptr)
>>> - {
>>> - int return_value = Mutex::TryLock();
>>> - if (return_value != 0 && failure_message != nullptr)
>>> - {
>>> - m_failure_message.assign(failure_message);
>>> - m_thread_that_tried = pthread_self();
>>> - }
>>> - return return_value;
>>> - }
>>> -
>>> -protected:
>>> - pthread_t m_thread_that_tried;
>>> - std::string m_failure_message;
>>> -};
>>> -
>>> -class LoggingMutex : public Mutex
>>> -{
>>> -public:
>>> - LoggingMutex() : Mutex(),m_locked(false) {}
>>> - LoggingMutex(Mutex::Type type) : Mutex (type),m_locked(false) {}
>>> -
>>> - virtual
>>> - ~LoggingMutex() = default;
>>> -
>>> - virtual int
>>> - Lock ();
>>> -
>>> - virtual int
>>> - Unlock ();
>>> -
>>> - virtual int
>>> - TryLock(const char *failure_message = nullptr);
>>> -
>>> -protected:
>>> - bool m_locked;
>>> -};
>>> -#endif // LLDB_CONFIGURATION_DEBUG
>>> -
>>> -} // namespace lldb_private
>>> -
>>> -#endif // liblldb_Mutex_h_
>>>
>>> Modified: lldb/trunk/include/lldb/Host/Predicate.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/Predicate.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Host/Predicate.h (original)
>>> +++ lldb/trunk/include/lldb/Host/Predicate.h Thu Jul 28 12:32:20 2016
>>> @@ -15,11 +15,12 @@
>>> #include <time.h>
>>>
>>> // C++ Includes
>>> +#include <condition_variable>
>>> +#include <mutex>
>>> +
>>> // Other libraries and framework includes
>>> // Project includes
>>> #include "lldb/lldb-defines.h"
>>> -#include "lldb/Host/Mutex.h"
>>> -#include "lldb/Host/Condition.h"
>>>
>>> //#define DB_PTHREAD_LOG_EVENTS
>>>
>>> @@ -97,7 +98,7 @@ public:
>>> T
>>> GetValue () const
>>> {
>>> - Mutex::Locker locker(m_mutex);
>>> + std::lock_guard<std::mutex> guard(m_mutex);
>>> T value = m_value;
>>> return value;
>>> }
>>> @@ -120,7 +121,7 @@ public:
>>> void
>>> SetValue (T value, PredicateBroadcastType broadcast_type)
>>> {
>>> - Mutex::Locker locker(m_mutex);
>>> + std::lock_guard<std::mutex> guard(m_mutex);
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> printf("%s (value = 0x%8.8x, broadcast_type = %i)\n",
>>> __FUNCTION__, value, broadcast_type);
>>> #endif
>>> @@ -148,7 +149,7 @@ public:
>>> void
>>> SetValueBits (T bits, PredicateBroadcastType broadcast_type)
>>> {
>>> - Mutex::Locker locker(m_mutex);
>>> + std::lock_guard<std::mutex> guard(m_mutex);
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> printf("%s (bits = 0x%8.8x, broadcast_type = %i)\n",
>>> __FUNCTION__, bits, broadcast_type);
>>> #endif
>>> @@ -176,7 +177,7 @@ public:
>>> void
>>> ResetValueBits (T bits, PredicateBroadcastType broadcast_type)
>>> {
>>> - Mutex::Locker locker(m_mutex);
>>> + std::lock_guard<std::mutex> guard(m_mutex);
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> printf("%s (bits = 0x%8.8x, broadcast_type = %i)\n",
>>> __FUNCTION__, bits, broadcast_type);
>>> #endif
>>> @@ -213,21 +214,30 @@ public:
>>> /// occurred.
>>> //------------------------------------------------------------------
>>> T
>>> - WaitForSetValueBits(T bits, const TimeValue *abstime = nullptr)
>>> + WaitForSetValueBits(T bits, const std::chrono::microseconds
>>> &timeout = std::chrono::microseconds(0))
>>> {
>>> - int err = 0;
>>> // pthread_cond_timedwait() or pthread_cond_wait() will
>>> atomically
>>> // unlock the mutex and wait for the condition to be set. When
>>> either
>>> // function returns, they will re-lock the mutex. We use an
>>> auto lock/unlock
>>> - // class (Mutex::Locker) to allow us to return at any point in
>>> this
>>> + // class (std::lock_guard) to allow us to return at any point
>>> in this
>>> // function and not have to worry about unlocking the mutex.
>>> - Mutex::Locker locker(m_mutex);
>>> + std::unique_lock<std::mutex> lock(m_mutex);
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> - printf("%s (bits = 0x%8.8x, abstime = %p), m_value =
>>> 0x%8.8x\n", __FUNCTION__, bits, abstime, m_value);
>>> + printf("%s (bits = 0x%8.8x, timeout = %llu), m_value =
>>> 0x%8.8x\n", __FUNCTION__, bits, timeout.count(),
>>> + m_value);
>>> #endif
>>> - while (err == 0 && ((m_value & bits) == 0))
>>> + while ((m_value & bits) == 0)
>>> {
>>> - err = m_condition.Wait (m_mutex, abstime);
>>> + if (timeout == std::chrono::microseconds(0))
>>> + {
>>> + m_condition.wait(lock);
>>> + }
>>> + else
>>> + {
>>> + std::cv_status result = m_condition.wait_for(lock,
>>> timeout);
>>> + if (result == std::cv_status::timeout)
>>> + break;
>>> + }
>>> }
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> printf("%s (bits = 0x%8.8x), m_value = 0x%8.8x, returning
>>> 0x%8.8x\n", __FUNCTION__, bits, m_value, m_value & bits);
>>> @@ -262,23 +272,31 @@ public:
>>> /// unrecoverable error occurs.
>>> //------------------------------------------------------------------
>>> T
>>> - WaitForResetValueBits(T bits, const TimeValue *abstime = nullptr)
>>> + WaitForResetValueBits(T bits, const std::chrono::microseconds
>>> &timeout = std::chrono::microseconds(0))
>>> {
>>> - int err = 0;
>>> -
>>> // pthread_cond_timedwait() or pthread_cond_wait() will
>>> atomically
>>> // unlock the mutex and wait for the condition to be set. When
>>> either
>>> // function returns, they will re-lock the mutex. We use an
>>> auto lock/unlock
>>> - // class (Mutex::Locker) to allow us to return at any point in
>>> this
>>> + // class (std::lock_guard) to allow us to return at any point
>>> in this
>>> // function and not have to worry about unlocking the mutex.
>>> - Mutex::Locker locker(m_mutex);
>>> + std::unique_lock<std::mutex> lock(m_mutex);
>>>
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> - printf("%s (bits = 0x%8.8x, abstime = %p), m_value =
>>> 0x%8.8x\n", __FUNCTION__, bits, abstime, m_value);
>>> + printf("%s (bits = 0x%8.8x, timeout = %llu), m_value =
>>> 0x%8.8x\n", __FUNCTION__, bits, timeout.count(),
>>> + m_value);
>>> #endif
>>> - while (err == 0 && ((m_value & bits) != 0))
>>> + while ((m_value & bits) != 0)
>>> {
>>> - err = m_condition.Wait (m_mutex, abstime);
>>> + if (timeout == std::chrono::microseconds(0))
>>> + {
>>> + m_condition.wait(lock);
>>> + }
>>> + else
>>> + {
>>> + std::cv_status result = m_condition.wait_for(lock,
>>> timeout);
>>> + if (result == std::cv_status::timeout)
>>> + break;
>>> + }
>>> }
>>>
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> @@ -317,25 +335,39 @@ public:
>>> /// @li \b false otherwise
>>> //------------------------------------------------------------------
>>> bool
>>> - WaitForValueEqualTo(T value, const TimeValue *abstime = nullptr,
>>> bool *timed_out = nullptr)
>>> + WaitForValueEqualTo(T value, const std::chrono::microseconds
>>> &timeout = std::chrono::microseconds(0),
>>> + bool *timed_out = nullptr)
>>> {
>>> - int err = 0;
>>> // pthread_cond_timedwait() or pthread_cond_wait() will
>>> atomically
>>> // unlock the mutex and wait for the condition to be set. When
>>> either
>>> // function returns, they will re-lock the mutex. We use an
>>> auto lock/unlock
>>> - // class (Mutex::Locker) to allow us to return at any point in
>>> this
>>> + // class (std::lock_guard) to allow us to return at any point
>>> in this
>>> // function and not have to worry about unlocking the mutex.
>>> - Mutex::Locker locker(m_mutex);
>>> + std::unique_lock<std::mutex> lock(m_mutex);
>>>
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> - printf("%s (value = 0x%8.8x, abstime = %p), m_value =
>>> 0x%8.8x\n", __FUNCTION__, value, abstime, m_value);
>>> + printf("%s (value = 0x%8.8x, timeout = %llu), m_value =
>>> 0x%8.8x\n", __FUNCTION__, value, timeout.count(),
>>> + m_value);
>>> #endif
>>> if (timed_out)
>>> *timed_out = false;
>>>
>>> - while (err == 0 && m_value != value)
>>> + while (m_value != value)
>>> {
>>> - err = m_condition.Wait (m_mutex, abstime, timed_out);
>>> + if (timeout == std::chrono::microseconds(0))
>>> + {
>>> + m_condition.wait(lock);
>>> + }
>>> + else
>>> + {
>>> + std::cv_status result = m_condition.wait_for(lock,
>>> timeout);
>>> + if (result == std::cv_status::timeout)
>>> + {
>>> + if (timed_out)
>>> + *timed_out = true;
>>> + break;
>>> + }
>>> + }
>>> }
>>>
>>> return m_value == value;
>>> @@ -378,26 +410,39 @@ public:
>>> //------------------------------------------------------------------
>>> bool
>>> WaitForValueEqualToAndSetValueTo(T wait_value, T new_value,
>>> - const TimeValue *abstime = nullptr,
>>> + const std::chrono::microseconds
>>> &timeout = std::chrono::microseconds(0),
>>> bool *timed_out = nullptr)
>>> {
>>> - int err = 0;
>>> // pthread_cond_timedwait() or pthread_cond_wait() will
>>> atomically
>>> // unlock the mutex and wait for the condition to be set. When
>>> either
>>> // function returns, they will re-lock the mutex. We use an
>>> auto lock/unlock
>>> - // class (Mutex::Locker) to allow us to return at any point in
>>> this
>>> + // class (std::lock_guard) to allow us to return at any point
>>> in this
>>> // function and not have to worry about unlocking the mutex.
>>> - Mutex::Locker locker(m_mutex);
>>> + std::unique_lock<std::mutex> lock(m_mutex);
>>>
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> - printf("%s (wait_value = 0x%8.8x, new_value = 0x%8.8x, abstime
>>> = %p), m_value = 0x%8.8x\n", __FUNCTION__, wait_value, new_value, abstime,
>>> m_value);
>>> + printf("%s (wait_value = 0x%8.8x, new_value = 0x%8.8x, timeout
>>> = %llu), m_value = 0x%8.8x\n", __FUNCTION__,
>>> + wait_value, new_value, timeout.count(), m_value);
>>> #endif
>>> if (timed_out)
>>> *timed_out = false;
>>>
>>> - while (err == 0 && m_value != wait_value)
>>> + while (m_value != wait_value)
>>> {
>>> - err = m_condition.Wait (m_mutex, abstime, timed_out);
>>> + if (timeout == std::chrono::microseconds(0))
>>> + {
>>> + m_condition.wait(lock);
>>> + }
>>> + else
>>> + {
>>> + std::cv_status result = m_condition.wait_for(m_mutex,
>>> timeout);
>>> + if (result == std::cv_status::timeout)
>>> + {
>>> + if (timed_out)
>>> + *timed_out = true;
>>> + break;
>>> + }
>>> + }
>>> }
>>>
>>> if (m_value == wait_value)
>>> @@ -438,21 +483,31 @@ public:
>>> /// @li \b false otherwise
>>> //------------------------------------------------------------------
>>> bool
>>> - WaitForValueNotEqualTo(T value, T &new_value, const TimeValue
>>> *abstime = nullptr)
>>> + WaitForValueNotEqualTo(T value, T &new_value,
>>> + const std::chrono::microseconds &timeout =
>>> std::chrono::microseconds(0))
>>> {
>>> - int err = 0;
>>> // pthread_cond_timedwait() or pthread_cond_wait() will
>>> atomically
>>> // unlock the mutex and wait for the condition to be set. When
>>> either
>>> // function returns, they will re-lock the mutex. We use an
>>> auto lock/unlock
>>> - // class (Mutex::Locker) to allow us to return at any point in
>>> this
>>> + // class (std::lock_guard) to allow us to return at any point
>>> in this
>>> // function and not have to worry about unlocking the mutex.
>>> - Mutex::Locker locker(m_mutex);
>>> + std::unique_lock<std::mutex> lock(m_mutex);
>>> #ifdef DB_PTHREAD_LOG_EVENTS
>>> - printf("%s (value = 0x%8.8x, abstime = %p), m_value =
>>> 0x%8.8x\n", __FUNCTION__, value, abstime, m_value);
>>> + printf("%s (value = 0x%8.8x, timeout = %llu), m_value =
>>> 0x%8.8x\n", __FUNCTION__, value, timeout.count(),
>>> + m_value);
>>> #endif
>>> - while (err == 0 && m_value == value)
>>> + while (m_value == value)
>>> {
>>> - err = m_condition.Wait (m_mutex, abstime);
>>> + if (timeout == std::chrono::microseconds(0))
>>> + {
>>> + m_condition.wait(lock);
>>> + }
>>> + else
>>> + {
>>> + std::cv_status result = m_condition.wait_for(lock,
>>> timeout);
>>> + if (result == std::cv_status::timeout)
>>> + break;
>>> + }
>>> }
>>>
>>> if (m_value != value)
>>> @@ -469,8 +524,9 @@ protected:
>>> // blocking between the main thread and the spotlight index thread.
>>>
>>> //----------------------------------------------------------------------
>>> T m_value; ///< The templatized value T that we
>>> are protecting access to
>>> - mutable Mutex m_mutex; ///< The mutex to use when accessing
>>> the data
>>> - Condition m_condition; ///< The pthread condition variable to
>>> use for signaling that data available or changed.
>>> + mutable std::mutex m_mutex; ///< The mutex to use when accessing
>>> the data
>>> + std::condition_variable
>>> + m_condition; ///< The pthread condition variable to use for
>>> signaling that data available or changed.
>>>
>>> private:
>>> //------------------------------------------------------------------
>>> @@ -496,7 +552,7 @@ private:
>>> printf("%s (old_value = 0x%8.8x, broadcast_type = %i) m_value =
>>> 0x%8.8x, broadcast = %u\n", __FUNCTION__, old_value, broadcast_type,
>>> m_value, broadcast);
>>> #endif
>>> if (broadcast)
>>> - m_condition.Broadcast();
>>> + m_condition.notify_all();
>>> }
>>>
>>> DISALLOW_COPY_AND_ASSIGN(Predicate);
>>>
>>> Modified: lldb/trunk/include/lldb/Host/ProcessRunLock.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Host/ProcessRunLock.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Host/ProcessRunLock.h (original)
>>> +++ lldb/trunk/include/lldb/Host/ProcessRunLock.h Thu Jul 28 12:32:20
>>> 2016
>>> @@ -18,7 +18,6 @@
>>> // Other libraries and framework includes
>>> // Project includes
>>> #include "lldb/lldb-defines.h"
>>> -#include "lldb/Host/Condition.h"
>>>
>>> //----------------------------------------------------------------------
>>> /// Enumerations for broadcasting.
>>>
>>> Modified: lldb/trunk/include/lldb/Target/Process.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/include/lldb/Target/Process.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/include/lldb/Target/Process.h (original)
>>> +++ lldb/trunk/include/lldb/Target/Process.h Thu Jul 28 12:32:20 2016
>>> @@ -16,6 +16,7 @@
>>> #include <limits.h>
>>>
>>> // C++ Includes
>>> +#include <chrono>
>>> #include <list>
>>> #include <memory>
>>> #include <mutex>
>>> @@ -2920,12 +2921,9 @@ public:
>>> // function releases the run lock after the stop. Setting
>>> use_run_lock to false
>>> // will avoid this behavior.
>>> lldb::StateType
>>> - WaitForProcessToStop(const TimeValue *timeout,
>>> - lldb::EventSP *event_sp_ptr = nullptr,
>>> - bool wait_always = true,
>>> - lldb::ListenerSP hijack_listener =
>>> lldb::ListenerSP(),
>>> - Stream *stream = nullptr,
>>> - bool use_run_lock = true);
>>> + WaitForProcessToStop(const std::chrono::microseconds &timeout,
>>> lldb::EventSP *event_sp_ptr = nullptr,
>>> + bool wait_always = true, lldb::ListenerSP
>>> hijack_listener = lldb::ListenerSP(),
>>> + Stream *stream = nullptr, bool use_run_lock =
>>> true);
>>>
>>> uint32_t
>>> GetIOHandlerID () const
>>> @@ -2947,8 +2945,7 @@ public:
>>> SyncIOHandler (uint32_t iohandler_id, uint64_t timeout_msec);
>>>
>>> lldb::StateType
>>> - WaitForStateChangedEvents(const TimeValue *timeout,
>>> - lldb::EventSP &event_sp,
>>> + WaitForStateChangedEvents(const std::chrono::microseconds &timeout,
>>> lldb::EventSP &event_sp,
>>> lldb::ListenerSP hijack_listener); //
>>> Pass an empty ListenerSP to use builtin listener
>>>
>>>
>>> //--------------------------------------------------------------------------------------
>>> @@ -3538,21 +3535,20 @@ protected:
>>> HaltPrivate();
>>>
>>> lldb::StateType
>>> - WaitForProcessStopPrivate (const TimeValue *timeout, lldb::EventSP
>>> &event_sp);
>>> + WaitForProcessStopPrivate(const std::chrono::microseconds &timeout,
>>> lldb::EventSP &event_sp);
>>>
>>> // This waits for both the state change broadcaster, and the
>>> control broadcaster.
>>> // If control_only, it only waits for the control broadcaster.
>>>
>>> bool
>>> - WaitForEventsPrivate (const TimeValue *timeout, lldb::EventSP
>>> &event_sp, bool control_only);
>>> + WaitForEventsPrivate(const std::chrono::microseconds &timeout,
>>> lldb::EventSP &event_sp, bool control_only);
>>>
>>> lldb::StateType
>>> - WaitForStateChangedEventsPrivate (const TimeValue *timeout,
>>> lldb::EventSP &event_sp);
>>> + WaitForStateChangedEventsPrivate(const std::chrono::microseconds
>>> &timeout, lldb::EventSP &event_sp);
>>>
>>> lldb::StateType
>>> - WaitForState (const TimeValue *timeout,
>>> - const lldb::StateType *match_states,
>>> - const uint32_t num_match_states);
>>> + WaitForState(const std::chrono::microseconds &timeout, const
>>> lldb::StateType *match_states,
>>> + const uint32_t num_match_states);
>>>
>>> size_t
>>> WriteMemoryPrivate (lldb::addr_t addr, const void *buf, size_t
>>> size, Error &error);
>>>
>>> Modified: lldb/trunk/source/API/SBListener.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SBListener.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/API/SBListener.cpp (original)
>>> +++ lldb/trunk/source/API/SBListener.cpp Thu Jul 28 12:32:20 2016
>>> @@ -17,7 +17,6 @@
>>> #include "lldb/Core/Listener.h"
>>> #include "lldb/Core/Log.h"
>>> #include "lldb/Core/StreamString.h"
>>> -#include "lldb/Host/TimeValue.h"
>>>
>>>
>>> using namespace lldb;
>>> @@ -202,15 +201,14 @@ SBListener::WaitForEvent (uint32_t timeo
>>>
>>> if (m_opaque_sp)
>>> {
>>> - TimeValue time_value;
>>> + std::chrono::microseconds timeout =
>>> std::chrono::microseconds(0);
>>> if (timeout_secs != UINT32_MAX)
>>> {
>>> assert (timeout_secs != 0); // Take this out after all
>>> calls with timeout set to zero have been removed....
>>> - time_value = TimeValue::Now();
>>> - time_value.OffsetWithSeconds (timeout_secs);
>>> + timeout = std::chrono::seconds(timeout_secs);
>>> }
>>> EventSP event_sp;
>>> - if (m_opaque_sp->WaitForEvent (time_value.IsValid() ?
>>> &time_value : NULL, event_sp))
>>> + if (m_opaque_sp->WaitForEvent(timeout, event_sp))
>>> {
>>> event.reset (event_sp);
>>> success = true;
>>> @@ -247,16 +245,11 @@ SBListener::WaitForEventForBroadcaster
>>> {
>>> if (m_opaque_sp && broadcaster.IsValid())
>>> {
>>> - TimeValue time_value;
>>> + std::chrono::microseconds timeout =
>>> std::chrono::microseconds(0);
>>> if (num_seconds != UINT32_MAX)
>>> - {
>>> - time_value = TimeValue::Now();
>>> - time_value.OffsetWithSeconds (num_seconds);
>>> - }
>>> + timeout = std::chrono::seconds(num_seconds);
>>> EventSP event_sp;
>>> - if (m_opaque_sp->WaitForEventForBroadcaster
>>> (time_value.IsValid() ? &time_value : NULL,
>>> -
>>> broadcaster.get(),
>>> - event_sp))
>>> + if (m_opaque_sp->WaitForEventForBroadcaster(timeout,
>>> broadcaster.get(), event_sp))
>>> {
>>> event.reset (event_sp);
>>> return true;
>>> @@ -278,17 +271,11 @@ SBListener::WaitForEventForBroadcasterWi
>>> {
>>> if (m_opaque_sp && broadcaster.IsValid())
>>> {
>>> - TimeValue time_value;
>>> + std::chrono::microseconds timeout =
>>> std::chrono::microseconds(0);
>>> if (num_seconds != UINT32_MAX)
>>> - {
>>> - time_value = TimeValue::Now();
>>> - time_value.OffsetWithSeconds (num_seconds);
>>> - }
>>> + timeout = std::chrono::seconds(num_seconds);
>>> EventSP event_sp;
>>> - if (m_opaque_sp->WaitForEventForBroadcasterWithType
>>> (time_value.IsValid() ? &time_value : NULL,
>>> -
>>> broadcaster.get(),
>>> -
>>> event_type_mask,
>>> - event_sp))
>>> + if (m_opaque_sp->WaitForEventForBroadcasterWithType(timeout,
>>> broadcaster.get(), event_type_mask, event_sp))
>>> {
>>> event.reset (event_sp);
>>> return true;
>>>
>>> Modified: lldb/trunk/source/Core/Communication.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Communication.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Core/Communication.cpp (original)
>>> +++ lldb/trunk/source/Core/Communication.cpp Thu Jul 28 12:32:20 2016
>>> @@ -156,18 +156,14 @@ Communication::Read (void *dst, size_t d
>>> status = eConnectionStatusNoConnection;
>>> return 0;
>>> }
>>> - // Set the timeout appropriately
>>> - TimeValue timeout_time;
>>> - if (timeout_usec != UINT32_MAX)
>>> - {
>>> - timeout_time = TimeValue::Now();
>>> - timeout_time.OffsetWithMicroSeconds (timeout_usec);
>>> - }
>>>
>>> ListenerSP
>>> listener_sp(Listener::MakeListener("Communication::Read"));
>>> listener_sp->StartListeningForEvents (this,
>>> eBroadcastBitReadThreadGotBytes | eBroadcastBitReadThreadDidExit);
>>> EventSP event_sp;
>>> - while (listener_sp->WaitForEvent (timeout_time.IsValid() ?
>>> &timeout_time : nullptr, event_sp))
>>> + std::chrono::microseconds timeout =
>>> std::chrono::microseconds(0);
>>> + if (timeout_usec != UINT32_MAX)
>>> + timeout = std::chrono::microseconds(timeout_usec);
>>> + while (listener_sp->WaitForEvent(timeout, event_sp))
>>> {
>>> const uint32_t event_type = event_sp->GetType();
>>> if (event_type & eBroadcastBitReadThreadGotBytes)
>>> @@ -439,7 +435,7 @@ Communication::SynchronizeWithReadThread
>>>
>>> // Wait for the synchronization event.
>>> EventSP event_sp;
>>> - listener_sp->WaitForEvent(nullptr, event_sp);
>>> + listener_sp->WaitForEvent(std::chrono::microseconds(0), event_sp);
>>> }
>>>
>>> void
>>>
>>> Modified: lldb/trunk/source/Core/Debugger.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Debugger.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Core/Debugger.cpp (original)
>>> +++ lldb/trunk/source/Core/Debugger.cpp Thu Jul 28 12:32:20 2016
>>> @@ -1608,7 +1608,7 @@ Debugger::DefaultEventHandler()
>>> while (!done)
>>> {
>>> EventSP event_sp;
>>> - if (listener_sp->WaitForEvent(nullptr, event_sp))
>>> + if (listener_sp->WaitForEvent(std::chrono::microseconds(0),
>>> event_sp))
>>> {
>>> if (event_sp)
>>> {
>>> @@ -1705,7 +1705,7 @@ Debugger::StartEventHandlerThread()
>>> // eBroadcastBitEventThreadIsListening so we don't need to
>>> check the event, we just need
>>> // to wait an infinite amount of time for it (nullptr timeout
>>> as the first parameter)
>>> lldb::EventSP event_sp;
>>> - listener_sp->WaitForEvent(nullptr, event_sp);
>>> + listener_sp->WaitForEvent(std::chrono::microseconds(0),
>>> event_sp);
>>> }
>>> return m_event_handler_thread.IsJoinable();
>>> }
>>>
>>> Modified: lldb/trunk/source/Core/Listener.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Core/Listener.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Core/Listener.cpp (original)
>>> +++ lldb/trunk/source/Core/Listener.cpp Thu Jul 28 12:32:20 2016
>>> @@ -19,7 +19,6 @@
>>> #include "lldb/Core/Log.h"
>>> #include "lldb/Core/StreamString.h"
>>> #include "lldb/Core/Event.h"
>>> -#include "lldb/Host/TimeValue.h"
>>>
>>> using namespace lldb;
>>> using namespace lldb_private;
>>> @@ -41,7 +40,7 @@ namespace
>>> } // anonymous namespace
>>>
>>> Listener::Listener(const char *name)
>>> - : m_name(name), m_broadcasters(), m_broadcasters_mutex(),
>>> m_events(), m_events_mutex(Mutex::eMutexTypeNormal)
>>> + : m_name(name), m_broadcasters(), m_broadcasters_mutex(),
>>> m_events(), m_events_mutex()
>>> {
>>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_OBJECT));
>>> if (log != nullptr)
>>> @@ -63,7 +62,7 @@ void
>>> Listener::Clear()
>>> {
>>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_OBJECT));
>>> - std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
>>> + std::lock_guard<std::recursive_mutex>
>>> broadcasters_guard(m_broadcasters_mutex);
>>> broadcaster_collection::iterator pos, end = m_broadcasters.end();
>>> for (pos = m_broadcasters.begin(); pos != end; ++pos)
>>> {
>>> @@ -73,7 +72,7 @@ Listener::Clear()
>>> }
>>> m_broadcasters.clear();
>>>
>>> - Mutex::Locker event_locker(m_events_mutex);
>>> + std::lock_guard<std::mutex> events_guard(m_events_mutex);
>>> m_events.clear();
>>> size_t num_managers = m_broadcaster_managers.size();
>>>
>>> @@ -96,7 +95,7 @@ Listener::StartListeningForEvents (Broad
>>> // Scope for "locker"
>>> // Tell the broadcaster to add this object as a listener
>>> {
>>> - std::lock_guard<std::recursive_mutex>
>>> guard(m_broadcasters_mutex);
>>> + std::lock_guard<std::recursive_mutex>
>>> broadcasters_guard(m_broadcasters_mutex);
>>> Broadcaster::BroadcasterImplWP
>>> impl_wp(broadcaster->GetBroadcasterImpl());
>>> m_broadcasters.insert(std::make_pair(impl_wp,
>>> BroadcasterInfo(event_mask)));
>>> }
>>> @@ -123,7 +122,7 @@ Listener::StartListeningForEvents (Broad
>>> // Scope for "locker"
>>> // Tell the broadcaster to add this object as a listener
>>> {
>>> - std::lock_guard<std::recursive_mutex>
>>> guard(m_broadcasters_mutex);
>>> + std::lock_guard<std::recursive_mutex>
>>> broadcasters_guard(m_broadcasters_mutex);
>>> Broadcaster::BroadcasterImplWP
>>> impl_wp(broadcaster->GetBroadcasterImpl());
>>> m_broadcasters.insert(std::make_pair(impl_wp,
>>>
>>> BroadcasterInfo(event_mask, callback, callback_user_data)));
>>> @@ -154,7 +153,7 @@ Listener::StopListeningForEvents (Broadc
>>> {
>>> // Scope for "locker"
>>> {
>>> - std::lock_guard<std::recursive_mutex>
>>> guard(m_broadcasters_mutex);
>>> + std::lock_guard<std::recursive_mutex>
>>> broadcasters_guard(m_broadcasters_mutex);
>>> m_broadcasters.erase (broadcaster->GetBroadcasterImpl());
>>> }
>>> // Remove the broadcaster from our set of broadcasters
>>> @@ -171,13 +170,13 @@ Listener::BroadcasterWillDestruct (Broad
>>> {
>>> // Scope for "broadcasters_locker"
>>> {
>>> - std::lock_guard<std::recursive_mutex>
>>> guard(m_broadcasters_mutex);
>>> + std::lock_guard<std::recursive_mutex>
>>> broadcasters_guard(m_broadcasters_mutex);
>>> m_broadcasters.erase (broadcaster->GetBroadcasterImpl());
>>> }
>>>
>>> // Scope for "event_locker"
>>> {
>>> - Mutex::Locker event_locker(m_events_mutex);
>>> + std::lock_guard<std::mutex> events_guard(m_events_mutex);
>>> // Remove all events for this broadcaster object.
>>> event_collection::iterator pos = m_events.begin();
>>> while (pos != m_events.end())
>>> @@ -212,9 +211,9 @@ Listener::AddEvent (EventSP &event_sp)
>>> static_cast<void*>(this), m_name.c_str(),
>>> static_cast<void*>(event_sp.get()));
>>>
>>> - Mutex::Locker locker(m_events_mutex);
>>> + std::lock_guard<std::mutex> guard(m_events_mutex);
>>> m_events.push_back (event_sp);
>>> - m_events_condition.Broadcast();
>>> + m_events_condition.notify_all();
>>> }
>>>
>>> class EventBroadcasterMatches
>>> @@ -279,15 +278,11 @@ private:
>>> };
>>>
>>> bool
>>> -Listener::FindNextEventInternal
>>> -(
>>> - Mutex::Locker& lock,
>>> - Broadcaster *broadcaster, // nullptr for any broadcaster
>>> - const ConstString *broadcaster_names, // nullptr for any event
>>> - uint32_t num_broadcaster_names,
>>> - uint32_t event_type_mask,
>>> - EventSP &event_sp,
>>> - bool remove)
>>> +Listener::FindNextEventInternal(std::unique_lock<std::mutex> &lock,
>>> + Broadcaster *broadcaster,
>>> // nullptr for any broadcaster
>>> + const ConstString *broadcaster_names,
>>> // nullptr for any event
>>> + uint32_t num_broadcaster_names,
>>> uint32_t event_type_mask, EventSP &event_sp,
>>> + bool remove)
>>> {
>>> // NOTE: callers of this function must lock m_events_mutex using a
>>> Mutex::Locker
>>> // and pass the locker as the first argument. m_events_mutex is no
>>> longer recursive.
>>> @@ -325,7 +320,7 @@ Listener::FindNextEventInternal
>>> // Unlock the event queue here. We've removed this event
>>> and are about to return
>>> // it so it should be okay to get the next event off the
>>> queue here - and it might
>>> // be useful to do that in the "DoOnRemoval".
>>> - lock.Unlock();
>>> + lock.unlock();
>>> event_sp->DoOnRemoval();
>>> }
>>> return true;
>>> @@ -338,9 +333,9 @@ Listener::FindNextEventInternal
>>> Event *
>>> Listener::PeekAtNextEvent ()
>>> {
>>> - Mutex::Locker lock(m_events_mutex);
>>> + std::unique_lock<std::mutex> guard(m_events_mutex);
>>> EventSP event_sp;
>>> - if (FindNextEventInternal(lock, nullptr, nullptr, 0, 0, event_sp,
>>> false))
>>> + if (FindNextEventInternal(guard, nullptr, nullptr, 0, 0, event_sp,
>>> false))
>>> return event_sp.get();
>>> return nullptr;
>>> }
>>> @@ -348,9 +343,9 @@ Listener::PeekAtNextEvent ()
>>> Event *
>>> Listener::PeekAtNextEventForBroadcaster (Broadcaster *broadcaster)
>>> {
>>> - Mutex::Locker lock(m_events_mutex);
>>> + std::unique_lock<std::mutex> guard(m_events_mutex);
>>> EventSP event_sp;
>>> - if (FindNextEventInternal(lock, broadcaster, nullptr, 0, 0,
>>> event_sp, false))
>>> + if (FindNextEventInternal(guard, broadcaster, nullptr, 0, 0,
>>> event_sp, false))
>>> return event_sp.get();
>>> return nullptr;
>>> }
>>> @@ -358,9 +353,9 @@ Listener::PeekAtNextEventForBroadcaster
>>> Event *
>>> Listener::PeekAtNextEventForBroadcasterWithType (Broadcaster
>>> *broadcaster, uint32_t event_type_mask)
>>> {
>>> - Mutex::Locker lock(m_events_mutex);
>>> + std::unique_lock<std::mutex> guard(m_events_mutex);
>>> EventSP event_sp;
>>> - if (FindNextEventInternal(lock, broadcaster, nullptr, 0,
>>> event_type_mask, event_sp, false))
>>> + if (FindNextEventInternal(guard, broadcaster, nullptr, 0,
>>> event_type_mask, event_sp, false))
>>> return event_sp.get();
>>> return nullptr;
>>> }
>>> @@ -372,8 +367,9 @@ Listener::GetNextEventInternal(Broadcast
>>> uint32_t event_type_mask,
>>> EventSP &event_sp)
>>> {
>>> - Mutex::Locker lock(m_events_mutex);
>>> - return FindNextEventInternal (lock, broadcaster, broadcaster_names,
>>> num_broadcaster_names, event_type_mask, event_sp, true);
>>> + std::unique_lock<std::mutex> guard(m_events_mutex);
>>> + return FindNextEventInternal(guard, broadcaster, broadcaster_names,
>>> num_broadcaster_names, event_type_mask,
>>> + event_sp, true);
>>> }
>>>
>>> bool
>>> @@ -395,20 +391,17 @@ Listener::GetNextEventForBroadcasterWith
>>> }
>>>
>>> bool
>>> -Listener::WaitForEventsInternal(const TimeValue *timeout,
>>> +Listener::WaitForEventsInternal(const std::chrono::microseconds
>>> &timeout,
>>> Broadcaster *broadcaster,
>>> // nullptr for any broadcaster
>>> const ConstString *broadcaster_names,
>>> // nullptr for any event
>>> - uint32_t num_broadcaster_names,
>>> - uint32_t event_type_mask,
>>> - EventSP &event_sp)
>>> + uint32_t num_broadcaster_names,
>>> uint32_t event_type_mask, EventSP &event_sp)
>>> {
>>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_EVENTS));
>>> if (log != nullptr)
>>> - log->Printf ("%p Listener::WaitForEventsInternal (timeout = {
>>> %p }) for %s",
>>> - static_cast<void*>(this), static_cast<const
>>> void*>(timeout),
>>> - m_name.c_str());
>>> + log->Printf("%p Listener::WaitForEventsInternal (timeout = %llu
>>> us) for %s", static_cast<void *>(this),
>>> + static_cast<unsigned long long>(timeout.count()),
>>> m_name.c_str());
>>>
>>> - Mutex::Locker lock(m_events_mutex);
>>> + std::unique_lock<std::mutex> lock(m_events_mutex);
>>>
>>> while (true)
>>> {
>>> @@ -418,23 +411,26 @@ Listener::WaitForEventsInternal(const Ti
>>> }
>>> else
>>> {
>>> - bool timed_out = false;
>>> - if (m_events_condition.Wait(m_events_mutex, timeout,
>>> &timed_out) != 0)
>>> + std::cv_status result = std::cv_status::no_timeout;
>>> + if (timeout == std::chrono::microseconds(0))
>>> + m_events_condition.wait(lock);
>>> + else
>>> + result = m_events_condition.wait_for(lock, timeout);
>>> +
>>> + if (result == std::cv_status::timeout)
>>> {
>>> - if (timed_out)
>>> - {
>>> - log = lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_EVENTS);
>>> - if (log != nullptr)
>>> - log->Printf ("%p
>>> Listener::WaitForEventsInternal() timed out for %s",
>>> - static_cast<void*>(this),
>>> m_name.c_str());
>>> - }
>>> - else
>>> - {
>>> - log = lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_EVENTS);
>>> - if (log != nullptr)
>>> - log->Printf ("%p
>>> Listener::WaitForEventsInternal() unknown error for %s",
>>> - static_cast<void*>(this),
>>> m_name.c_str());
>>> - }
>>> + log =
>>> lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
>>> + if (log)
>>> + log->Printf("%p Listener::WaitForEventsInternal()
>>> timed out for %s", static_cast<void *>(this),
>>> + m_name.c_str());
>>> + return false;
>>> + }
>>> + else if (result != std::cv_status::no_timeout)
>>> + {
>>> + log =
>>> lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
>>> + if (log)
>>> + log->Printf("%p Listener::WaitForEventsInternal()
>>> unknown error for %s", static_cast<void *>(this),
>>> + m_name.c_str());
>>> return false;
>>> }
>>> }
>>> @@ -444,24 +440,21 @@ Listener::WaitForEventsInternal(const Ti
>>> }
>>>
>>> bool
>>> -Listener::WaitForEventForBroadcasterWithType(const TimeValue *timeout,
>>> - Broadcaster *broadcaster,
>>> - uint32_t event_type_mask,
>>> - EventSP &event_sp)
>>> +Listener::WaitForEventForBroadcasterWithType(const
>>> std::chrono::microseconds &timeout, Broadcaster *broadcaster,
>>> + uint32_t event_type_mask,
>>> EventSP &event_sp)
>>> {
>>> return WaitForEventsInternal(timeout, broadcaster, nullptr, 0,
>>> event_type_mask, event_sp);
>>> }
>>>
>>> bool
>>> -Listener::WaitForEventForBroadcaster(const TimeValue *timeout,
>>> - Broadcaster *broadcaster,
>>> +Listener::WaitForEventForBroadcaster(const std::chrono::microseconds
>>> &timeout, Broadcaster *broadcaster,
>>> EventSP &event_sp)
>>> {
>>> return WaitForEventsInternal(timeout, broadcaster, nullptr, 0, 0,
>>> event_sp);
>>> }
>>>
>>> bool
>>> -Listener::WaitForEvent (const TimeValue *timeout, EventSP &event_sp)
>>> +Listener::WaitForEvent(const std::chrono::microseconds &timeout,
>>> EventSP &event_sp)
>>> {
>>> return WaitForEventsInternal(timeout, nullptr, nullptr, 0, 0,
>>> event_sp);
>>> }
>>>
>>> Modified: lldb/trunk/source/Host/CMakeLists.txt
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/CMakeLists.txt?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Host/CMakeLists.txt (original)
>>> +++ lldb/trunk/source/Host/CMakeLists.txt Thu Jul 28 12:32:20 2016
>>> @@ -4,7 +4,6 @@ macro(add_host_subdirectory group)
>>> endmacro()
>>>
>>> add_host_subdirectory(common
>>> - common/Condition.cpp
>>> common/File.cpp
>>> common/FileCache.cpp
>>> common/FileSpec.cpp
>>> @@ -17,7 +16,6 @@ add_host_subdirectory(common
>>> common/HostThread.cpp
>>> common/IOObject.cpp
>>> common/LockFileBase.cpp
>>> - common/Mutex.cpp
>>> common/MonitoringProcessLauncher.cpp
>>> common/NativeBreakpoint.cpp
>>> common/NativeBreakpointList.cpp
>>> @@ -60,7 +58,6 @@ add_host_subdirectory(posix
>>>
>>> if (CMAKE_SYSTEM_NAME MATCHES "Windows")
>>> add_host_subdirectory(windows
>>> - windows/Condition.cpp
>>> windows/ConnectionGenericFileWindows.cpp
>>> windows/EditLineWin.cpp
>>> windows/FileSystem.cpp
>>> @@ -69,7 +66,6 @@ if (CMAKE_SYSTEM_NAME MATCHES "Windows")
>>> windows/HostProcessWindows.cpp
>>> windows/HostThreadWindows.cpp
>>> windows/LockFileWindows.cpp
>>> - windows/Mutex.cpp
>>> windows/PipeWindows.cpp
>>> windows/ProcessLauncherWindows.cpp
>>> windows/ProcessRunLock.cpp
>>>
>>> Removed: lldb/trunk/source/Host/common/Condition.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/common/Condition.cpp?rev=277010&view=auto
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Host/common/Condition.cpp (original)
>>> +++ lldb/trunk/source/Host/common/Condition.cpp (removed)
>>> @@ -1,108 +0,0 @@
>>> -//===-- Condition.cpp -------------------------------------------*- C++
>>> -*-===//
>>> -//
>>> -// The LLVM Compiler Infrastructure
>>> -//
>>> -// This file is distributed under the University of Illinois Open Source
>>> -// License. See LICENSE.TXT for details.
>>> -//
>>>
>>> -//===----------------------------------------------------------------------===//
>>> -
>>> -#include <errno.h>
>>> -
>>> -#include "lldb/Host/Condition.h"
>>> -#include "lldb/Host/TimeValue.h"
>>> -
>>> -
>>> -using namespace lldb_private;
>>> -
>>> -#ifndef _WIN32
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Default constructor
>>> -//
>>> -// The default constructor will initialize a new pthread condition
>>> -// and maintain the condition in the object state.
>>> -//----------------------------------------------------------------------
>>> -Condition::Condition () :
>>> - m_condition()
>>> -{
>>> - ::pthread_cond_init (&m_condition, NULL);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Destructor
>>> -//
>>> -// Destroys the pthread condition that the object owns.
>>> -//----------------------------------------------------------------------
>>> -Condition::~Condition ()
>>> -{
>>> - ::pthread_cond_destroy (&m_condition);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Unblock all threads waiting for a condition variable
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Condition::Broadcast ()
>>> -{
>>> - return ::pthread_cond_broadcast (&m_condition);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Unblocks one thread waiting for the condition variable
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Condition::Signal ()
>>> -{
>>> - return ::pthread_cond_signal (&m_condition);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// The Wait() function atomically blocks the current thread
>>> -// waiting on the owned condition variable, and unblocks the mutex
>>> -// specified by "mutex". The waiting thread unblocks only after
>>> -// another thread calls Signal(), or Broadcast() with the same
>>> -// condition variable, or if "abstime" is valid (non-NULL) this
>>> -// function will return when the system time reaches the time
>>> -// specified in "abstime". If "abstime" is NULL this function will
>>> -// wait for an infinite amount of time for the condition variable
>>> -// to be signaled or broadcasted.
>>> -//
>>> -// The current thread re-acquires the lock on "mutex".
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Condition::Wait (Mutex &mutex, const TimeValue *abstime, bool
>>> *timed_out)
>>> -{
>>> - int err = 0;
>>> - do
>>> - {
>>> - if (abstime && abstime->IsValid())
>>> - {
>>> - struct timespec abstime_ts = abstime->GetAsTimeSpec();
>>> - err = ::pthread_cond_timedwait (&m_condition,
>>> mutex.GetMutex(), &abstime_ts);
>>> - }
>>> - else
>>> - err = ::pthread_cond_wait (&m_condition, mutex.GetMutex());
>>> - } while (err == EINTR);
>>> -
>>> - if (timed_out != NULL)
>>> - {
>>> - if (err == ETIMEDOUT)
>>> - *timed_out = true;
>>> - else
>>> - *timed_out = false;
>>> - }
>>> -
>>> - return err;
>>> -}
>>> -
>>> -#endif
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Get accessor to the pthread condition object
>>> -//----------------------------------------------------------------------
>>> -lldb::condition_t *
>>> -Condition::GetCondition()
>>> -{
>>> - return &m_condition;
>>> -}
>>>
>>> Modified: lldb/trunk/source/Host/common/Host.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/common/Host.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Host/common/Host.cpp (original)
>>> +++ lldb/trunk/source/Host/common/Host.cpp Thu Jul 28 12:32:20 2016
>>> @@ -620,14 +620,8 @@ Host::RunShellCommand(const Args &args,
>>>
>>> if (error.Success())
>>> {
>>> - TimeValue *timeout_ptr = nullptr;
>>> - TimeValue timeout_time(TimeValue::Now());
>>> - if (timeout_sec > 0) {
>>> - timeout_time.OffsetWithSeconds(timeout_sec);
>>> - timeout_ptr = &timeout_time;
>>> - }
>>> bool timed_out = false;
>>> - shell_info_sp->process_reaped.WaitForValueEqualTo(true,
>>> timeout_ptr, &timed_out);
>>> + shell_info_sp->process_reaped.WaitForValueEqualTo(true,
>>> std::chrono::seconds(timeout_sec), &timed_out);
>>> if (timed_out)
>>> {
>>> error.SetErrorString("timed out waiting for shell command
>>> to complete");
>>> @@ -635,10 +629,8 @@ Host::RunShellCommand(const Args &args,
>>> // Kill the process since it didn't complete within the
>>> timeout specified
>>> Kill (pid, SIGKILL);
>>> // Wait for the monitor callback to get the message
>>> - timeout_time = TimeValue::Now();
>>> - timeout_time.OffsetWithSeconds(1);
>>> timed_out = false;
>>> - shell_info_sp->process_reaped.WaitForValueEqualTo(true,
>>> &timeout_time, &timed_out);
>>> + shell_info_sp->process_reaped.WaitForValueEqualTo(true,
>>> std::chrono::seconds(1), &timed_out);
>>> }
>>> else
>>> {
>>>
>>> Removed: lldb/trunk/source/Host/common/Mutex.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/common/Mutex.cpp?rev=277010&view=auto
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Host/common/Mutex.cpp (original)
>>> +++ lldb/trunk/source/Host/common/Mutex.cpp (removed)
>>> @@ -1,398 +0,0 @@
>>> -//===-- Mutex.cpp -----------------------------------------------*- C++
>>> -*-===//
>>> -//
>>> -// The LLVM Compiler Infrastructure
>>> -//
>>> -// This file is distributed under the University of Illinois Open Source
>>> -// License. See LICENSE.TXT for details.
>>> -//
>>>
>>> -//===----------------------------------------------------------------------===//
>>> -
>>> -#include "lldb/Host/Mutex.h"
>>> -#include "lldb/Host/Host.h"
>>> -
>>> -#ifndef _WIN32
>>> -#include <pthread.h>
>>> -#endif
>>> -#include <string.h>
>>> -#include <stdio.h>
>>> -
>>> -#if 0
>>> -// This logging is way too verbose to enable even for a log channel.
>>> -// This logging can be enabled by changing the "#if 0", but should be
>>> -// reverted prior to checking in.
>>> -#include <cstdio>
>>> -#define DEBUG_LOG(fmt, ...) printf(fmt, ## __VA_ARGS__)
>>> -#else
>>> -#define DEBUG_LOG(fmt, ...)
>>> -#endif
>>> -
>>> -// Enable extra mutex error checking
>>> -#if 0 // LLDB_CONFIGURATION_DEBUG
>>> -#define ENABLE_MUTEX_ERROR_CHECKING 1
>>> -#include <inttypes.h>
>>> -#endif
>>> -
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> -#include <set>
>>> -
>>> -enum MutexAction
>>> -{
>>> - eMutexActionInitialized,
>>> - eMutexActionDestroyed,
>>> - eMutexActionAssertInitialized
>>> -};
>>> -
>>> -static bool
>>> -error_check_mutex (pthread_mutex_t *m, MutexAction action)
>>> -{
>>> - typedef std::set<pthread_mutex_t *> mutex_set;
>>> - static pthread_mutex_t g_mutex_set_mutex =
>>> PTHREAD_MUTEX_INITIALIZER;
>>> - static mutex_set g_initialized_mutex_set;
>>> - static mutex_set g_destroyed_mutex_set;
>>> -
>>> - bool success = true;
>>> - int err;
>>> - // Manually call lock so we don't to any of this error checking
>>> - err = ::pthread_mutex_lock (&g_mutex_set_mutex);
>>> - assert(err == 0);
>>> - switch (action)
>>> - {
>>> - case eMutexActionInitialized:
>>> - // Make sure this isn't already in our initialized mutex
>>> set...
>>> - assert (g_initialized_mutex_set.find(m) ==
>>> g_initialized_mutex_set.end());
>>> - // Remove this from the destroyed set in case it was ever
>>> in there
>>> - g_destroyed_mutex_set.erase(m);
>>> - // Add the mutex to the initialized set
>>> - g_initialized_mutex_set.insert(m);
>>> - break;
>>> -
>>> - case eMutexActionDestroyed:
>>> - // Make sure this isn't already in our destroyed mutex
>>> set...
>>> - assert (g_destroyed_mutex_set.find(m) ==
>>> g_destroyed_mutex_set.end());
>>> - // Remove this from the initialized so we can put it into
>>> the destroyed set
>>> - g_initialized_mutex_set.erase(m);
>>> - // Add the mutex to the destroyed set
>>> - g_destroyed_mutex_set.insert(m);
>>> - break;
>>> - case eMutexActionAssertInitialized:
>>> - // This function will return true if "m" is in the
>>> initialized mutex set
>>> - success = g_initialized_mutex_set.find(m) !=
>>> g_initialized_mutex_set.end();
>>> - assert (success);
>>> - break;
>>> - }
>>> - // Manually call unlock so we don't to any of this error checking
>>> - err = ::pthread_mutex_unlock (&g_mutex_set_mutex);
>>> - assert(err == 0);
>>> - return success;
>>> -}
>>> -
>>> -#endif
>>> -
>>> -using namespace lldb_private;
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Default constructor.
>>> -//
>>> -// This will create a scoped mutex locking object that doesn't have
>>> -// a mutex to lock. One will need to be provided using the Reset()
>>> -// method.
>>> -//----------------------------------------------------------------------
>>> -Mutex::Locker::Locker () :
>>> - m_mutex_ptr(NULL)
>>> -{
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Constructor with a Mutex object.
>>> -//
>>> -// This will create a scoped mutex locking object that extracts the
>>> -// mutex owned by "m" and locks it.
>>> -//----------------------------------------------------------------------
>>> -Mutex::Locker::Locker (Mutex& m) :
>>> - m_mutex_ptr(NULL)
>>> -{
>>> - Lock (m);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Constructor with a Mutex object pointer.
>>> -//
>>> -// This will create a scoped mutex locking object that extracts the
>>> -// mutex owned by "m" and locks it.
>>> -//----------------------------------------------------------------------
>>> -Mutex::Locker::Locker (Mutex* m) :
>>> - m_mutex_ptr(NULL)
>>> -{
>>> - if (m)
>>> - Lock (m);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Destructor
>>> -//
>>> -// Unlocks any owned mutex object (if it is valid).
>>> -//----------------------------------------------------------------------
>>> -Mutex::Locker::~Locker ()
>>> -{
>>> - Unlock();
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Unlock the current mutex in this object (if this owns a valid
>>> -// mutex) and lock the new "mutex" object if it is non-NULL.
>>> -//----------------------------------------------------------------------
>>> -void
>>> -Mutex::Locker::Lock (Mutex &mutex)
>>> -{
>>> - // We already have this mutex locked or both are NULL...
>>> - if (m_mutex_ptr == &mutex)
>>> - return;
>>> -
>>> - Unlock ();
>>> -
>>> - m_mutex_ptr = &mutex;
>>> - m_mutex_ptr->Lock();
>>> -}
>>> -
>>> -void
>>> -Mutex::Locker::Unlock ()
>>> -{
>>> - if (m_mutex_ptr)
>>> - {
>>> - m_mutex_ptr->Unlock ();
>>> - m_mutex_ptr = NULL;
>>> - }
>>> -}
>>> -
>>> -bool
>>> -Mutex::Locker::TryLock (Mutex &mutex, const char *failure_message)
>>> -{
>>> - // We already have this mutex locked!
>>> - if (m_mutex_ptr == &mutex)
>>> - return true;
>>> -
>>> - Unlock ();
>>> -
>>> - if (mutex.TryLock(failure_message) == 0)
>>> - m_mutex_ptr = &mutex;
>>> -
>>> - return m_mutex_ptr != NULL;
>>> -}
>>> -
>>> -#ifndef _WIN32
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Default constructor.
>>> -//
>>> -// Creates a pthread mutex with no attributes.
>>> -//----------------------------------------------------------------------
>>> -Mutex::Mutex () :
>>> - m_mutex()
>>> -{
>>> - int err;
>>> - err = ::pthread_mutex_init (&m_mutex, NULL);
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> - if (err == 0)
>>> - error_check_mutex (&m_mutex, eMutexActionInitialized);
>>> -#endif
>>> - assert(err == 0);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Default constructor.
>>> -//
>>> -// Creates a pthread mutex with "type" as the mutex type.
>>> -//----------------------------------------------------------------------
>>> -Mutex::Mutex (Mutex::Type type) :
>>> - m_mutex()
>>> -{
>>> - int err;
>>> - ::pthread_mutexattr_t attr;
>>> - err = ::pthread_mutexattr_init (&attr);
>>> - assert(err == 0);
>>> - switch (type)
>>> - {
>>> - case eMutexTypeNormal:
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> - err = ::pthread_mutexattr_settype (&attr,
>>> PTHREAD_MUTEX_ERRORCHECK);
>>> -#else
>>> - err = ::pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_NORMAL);
>>> -#endif
>>> - break;
>>> -
>>> - case eMutexTypeRecursive:
>>> - err = ::pthread_mutexattr_settype (&attr,
>>> PTHREAD_MUTEX_RECURSIVE);
>>> - break;
>>> - }
>>> - assert(err == 0);
>>> - err = ::pthread_mutex_init (&m_mutex, &attr);
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> - if (err == 0)
>>> - error_check_mutex (&m_mutex, eMutexActionInitialized);
>>> -#endif
>>> - assert(err == 0);
>>> - err = ::pthread_mutexattr_destroy (&attr);
>>> - assert(err == 0);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Destructor.
>>> -//
>>> -// Destroys the mutex owned by this object.
>>> -//----------------------------------------------------------------------
>>> -Mutex::~Mutex()
>>> -{
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> - int err = ::pthread_mutex_destroy (&m_mutex);
>>> - assert(err == 0);
>>> - if (err == 0)
>>> - error_check_mutex (&m_mutex, eMutexActionDestroyed);
>>> - else
>>> - {
>>> - Host::SetCrashDescriptionWithFormat ("%s error:
>>> pthread_mutex_destroy() => err = %i (%s)", __PRETTY_FUNCTION__, err,
>>> strerror(err));
>>> - assert(err == 0);
>>> - }
>>> - memset (&m_mutex, '\xba', sizeof(m_mutex));
>>> -#else
>>> - ::pthread_mutex_destroy (&m_mutex);
>>> -#endif
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Locks the mutex owned by this object, if the mutex is already
>>> -// locked, the calling thread will block until the mutex becomes
>>> -// available.
>>> -//
>>> -// RETURNS
>>> -// The error code from the pthread_mutex_lock() function call.
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Mutex::Lock()
>>> -{
>>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_lock
>>> (%p)...\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>>> &m_mutex);
>>> -
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> - error_check_mutex (&m_mutex, eMutexActionAssertInitialized);
>>> -#endif
>>> -
>>> - int err = ::pthread_mutex_lock (&m_mutex);
>>> -
>>> -
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> - if (err)
>>> - {
>>> - Host::SetCrashDescriptionWithFormat ("%s error:
>>> pthread_mutex_lock(%p) => err = %i (%s)", __PRETTY_FUNCTION__, &m_mutex,
>>> err, strerror(err));
>>> - assert(err == 0);
>>> - }
>>> -#endif
>>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_lock (%p)
>>> => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>>> &m_mutex, err);
>>> - return err;
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Attempts to lock the mutex owned by this object without blocking.
>>> -// If the mutex is already locked, TryLock() will not block waiting
>>> -// for the mutex, but will return an error condition.
>>> -//
>>> -// RETURNS
>>> -// The error code from the pthread_mutex_trylock() function call.
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Mutex::TryLock(const char *failure_message)
>>> -{
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> - error_check_mutex (&m_mutex, eMutexActionAssertInitialized);
>>> -#endif
>>> -
>>> - int err = ::pthread_mutex_trylock (&m_mutex);
>>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_trylock
>>> (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>>> &m_mutex, err);
>>> - return err;
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// If the current thread holds the lock on the owned mutex, then
>>> -// Unlock() will unlock the mutex. Calling Unlock() on this object
>>> -// that the calling thread does not hold will result in undefined
>>> -// behavior.
>>> -//
>>> -// RETURNS
>>> -// The error code from the pthread_mutex_unlock() function call.
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Mutex::Unlock()
>>> -{
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> - error_check_mutex (&m_mutex, eMutexActionAssertInitialized);
>>> -#endif
>>> -
>>> - int err = ::pthread_mutex_unlock (&m_mutex);
>>> -
>>> -#if ENABLE_MUTEX_ERROR_CHECKING
>>> - if (err)
>>> - {
>>> - Host::SetCrashDescriptionWithFormat ("%s error:
>>> pthread_mutex_unlock(%p) => err = %i (%s)", __PRETTY_FUNCTION__, &m_mutex,
>>> err, strerror(err));
>>> - assert(err == 0);
>>> - }
>>> -#endif
>>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_unlock
>>> (%p) => %i\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>>> &m_mutex, err);
>>> - return err;
>>> -}
>>> -
>>> -#endif
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Mutex get accessor.
>>> -//----------------------------------------------------------------------
>>> -lldb::mutex_t *
>>> -Mutex::GetMutex()
>>> -{
>>> - return &m_mutex;
>>> -}
>>> -
>>> -#ifdef LLDB_CONFIGURATION_DEBUG
>>> -int
>>> -TrackingMutex::Unlock ()
>>> -{
>>> - if (!m_failure_message.empty())
>>> - Host::SetCrashDescriptionWithFormat ("Unlocking lock (on thread
>>> %p) that thread: %p failed to get: %s",
>>> - pthread_self(),
>>> - m_thread_that_tried,
>>> - m_failure_message.c_str());
>>> - assert (m_failure_message.empty());
>>> - return Mutex::Unlock();
>>> -}
>>> -
>>> -int
>>> -LoggingMutex::Lock ()
>>> -{
>>> - printf("locking mutex %p by [%4.4" PRIx64 "/%4.4" PRIx64 "]...",
>>> this, Host::GetCurrentProcessID(), Host::GetCurrentThreadID());
>>> - int x = Mutex::Lock();
>>> - m_locked = true;
>>> - printf("%d\n",x);
>>> - return x;
>>> -}
>>> -
>>> -int
>>> -LoggingMutex::Unlock ()
>>> -{
>>> - printf("unlocking mutex %p by [%4.4" PRIx64 "/%4.4" PRIx64 "]...",
>>> this, Host::GetCurrentProcessID(), Host::GetCurrentThreadID());
>>> - int x = Mutex::Unlock();
>>> - m_locked = false;
>>> - printf("%d\n",x);
>>> - return x;
>>> -}
>>> -
>>> -int
>>> -LoggingMutex::TryLock (const char *failure_message)
>>> -{
>>> - printf("trylocking mutex %p by [%4.4" PRIx64 "/%4.4" PRIx64 "]...",
>>> this, Host::GetCurrentProcessID(), Host::GetCurrentThreadID());
>>> - int x = Mutex::TryLock(failure_message);
>>> - if (x == 0)
>>> - m_locked = true;
>>> - printf("%d\n",x);
>>> - return x;
>>> -}
>>> -
>>> -#endif
>>> -
>>> -
>>>
>>> Modified: lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp
>>> (original)
>>> +++ lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp Thu
>>> Jul 28 12:32:20 2016
>>> @@ -877,11 +877,7 @@ ConnectionFileDescriptor::GetListeningPo
>>> if (timeout_sec == UINT32_MAX)
>>> m_port_predicate.WaitForValueNotEqualTo(0, bound_port);
>>> else
>>> - {
>>> - TimeValue timeout = TimeValue::Now();
>>> - timeout.OffsetWithSeconds(timeout_sec);
>>> - m_port_predicate.WaitForValueNotEqualTo(0, bound_port,
>>> &timeout);
>>> - }
>>> + m_port_predicate.WaitForValueNotEqualTo(0, bound_port,
>>> std::chrono::seconds(timeout_sec));
>>> return bound_port;
>>> }
>>>
>>>
>>> Removed: lldb/trunk/source/Host/windows/Condition.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/windows/Condition.cpp?rev=277010&view=auto
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Host/windows/Condition.cpp (original)
>>> +++ lldb/trunk/source/Host/windows/Condition.cpp (removed)
>>> @@ -1,98 +0,0 @@
>>> -//===-- Condition.cpp -------------------------------------------*- C++
>>> -*-===//
>>> -//
>>> -// The LLVM Compiler Infrastructure
>>> -//
>>> -// This file is distributed under the University of Illinois Open Source
>>> -// License. See LICENSE.TXT for details.
>>> -//
>>>
>>> -//===----------------------------------------------------------------------===//
>>> -
>>> -#include <errno.h>
>>> -
>>> -#include "lldb/Host/Condition.h"
>>> -#include "lldb/Host/TimeValue.h"
>>> -#include "lldb/Host/windows/windows.h"
>>> -
>>> -
>>> -using namespace lldb_private;
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Default constructor
>>> -//
>>> -// The default constructor will initialize a new pthread condition
>>> -// and maintain the condition in the object state.
>>> -//----------------------------------------------------------------------
>>> -Condition::Condition () :
>>> - m_condition()
>>> -{
>>> - m_condition =
>>> static_cast<PCONDITION_VARIABLE>(malloc(sizeof(CONDITION_VARIABLE)));
>>> -
>>> InitializeConditionVariable(static_cast<PCONDITION_VARIABLE>(m_condition));
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Destructor
>>> -//
>>> -// Destroys the pthread condition that the object owns.
>>> -//----------------------------------------------------------------------
>>> -Condition::~Condition ()
>>> -{
>>> - free(m_condition);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Unblock all threads waiting for a condition variable
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Condition::Broadcast ()
>>> -{
>>> -
>>> WakeAllConditionVariable(static_cast<PCONDITION_VARIABLE>(m_condition));
>>> - return 0;
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Unblocks one thread waiting for the condition variable
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Condition::Signal ()
>>> -{
>>> -
>>> WakeConditionVariable(static_cast<PCONDITION_VARIABLE>(m_condition));
>>> - return 0;
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// The Wait() function atomically blocks the current thread
>>> -// waiting on the owned condition variable, and unblocks the mutex
>>> -// specified by "mutex". The waiting thread unblocks only after
>>> -// another thread calls Signal(), or Broadcast() with the same
>>> -// condition variable, or if "abstime" is valid (non-NULL) this
>>> -// function will return when the system time reaches the time
>>> -// specified in "abstime". If "abstime" is NULL this function will
>>> -// wait for an infinite amount of time for the condition variable
>>> -// to be signaled or broadcasted.
>>> -//
>>> -// The current thread re-acquires the lock on "mutex".
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Condition::Wait (Mutex &mutex, const TimeValue *abstime, bool
>>> *timed_out)
>>> -{
>>> - DWORD wait = INFINITE;
>>> - if (abstime != NULL) {
>>> - int wval = (*abstime - TimeValue::Now()) / 1000000;
>>> - if (wval < 0) wval = 0;
>>> -
>>> - wait = wval;
>>> - }
>>> -
>>> - int err =
>>> SleepConditionVariableCS(static_cast<PCONDITION_VARIABLE>(m_condition),
>>> static_cast<PCRITICAL_SECTION>(mutex.m_mutex), wait);
>>> -
>>> - if (timed_out != NULL)
>>> - {
>>> - if ((err == 0) && GetLastError() == ERROR_TIMEOUT)
>>> - *timed_out = true;
>>> - else
>>> - *timed_out = false;
>>> - }
>>> -
>>> - return err == 0;
>>> -}
>>> -
>>>
>>> Removed: lldb/trunk/source/Host/windows/Mutex.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Host/windows/Mutex.cpp?rev=277010&view=auto
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Host/windows/Mutex.cpp (original)
>>> +++ lldb/trunk/source/Host/windows/Mutex.cpp (removed)
>>> @@ -1,109 +0,0 @@
>>> -//===-- Mutex.cpp -----------------------------------------------*- C++
>>> -*-===//
>>> -//
>>> -// The LLVM Compiler Infrastructure
>>> -//
>>> -// This file is distributed under the University of Illinois Open Source
>>> -// License. See LICENSE.TXT for details.
>>> -//
>>>
>>> -//===----------------------------------------------------------------------===//
>>> -
>>> -#include "lldb/Host/Mutex.h"
>>> -#include "lldb/Host/Host.h"
>>> -#include "lldb/Host/windows/windows.h"
>>> -
>>> -#include <string.h>
>>> -#include <stdio.h>
>>> -
>>> -#if 0
>>> -// This logging is way too verbose to enable even for a log channel.
>>> -// This logging can be enabled by changing the "#if 0", but should be
>>> -// reverted prior to checking in.
>>> -#include <cstdio>
>>> -#define DEBUG_LOG(fmt, ...) printf(fmt, ## __VA_ARGS__)
>>> -#else
>>> -#define DEBUG_LOG(fmt, ...)
>>> -#endif
>>> -
>>> -using namespace lldb_private;
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Default constructor.
>>> -//
>>> -// Creates a pthread mutex with no attributes.
>>> -//----------------------------------------------------------------------
>>> -Mutex::Mutex () :
>>> - m_mutex()
>>> -{
>>> - m_mutex =
>>> static_cast<PCRITICAL_SECTION>(malloc(sizeof(CRITICAL_SECTION)));
>>> - InitializeCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Default constructor.
>>> -//
>>> -// Creates a pthread mutex with "type" as the mutex type.
>>> -//----------------------------------------------------------------------
>>> -Mutex::Mutex (Mutex::Type type) :
>>> - m_mutex()
>>> -{
>>> - m_mutex =
>>> static_cast<PCRITICAL_SECTION>(malloc(sizeof(CRITICAL_SECTION)));
>>> - InitializeCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Destructor.
>>> -//
>>> -// Destroys the mutex owned by this object.
>>> -//----------------------------------------------------------------------
>>> -Mutex::~Mutex()
>>> -{
>>> - DeleteCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>>> - free(m_mutex);
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Locks the mutex owned by this object, if the mutex is already
>>> -// locked, the calling thread will block until the mutex becomes
>>> -// available.
>>> -//
>>> -// RETURNS
>>> -// The error code from the pthread_mutex_lock() function call.
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Mutex::Lock()
>>> -{
>>> - DEBUG_LOG ("[%4.4" PRIx64 "/%4.4" PRIx64 "] pthread_mutex_lock
>>> (%p)...\n", Host::GetCurrentProcessID(), Host::GetCurrentThreadID(),
>>> m_mutex);
>>> -
>>> - EnterCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>>> - return 0;
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// Attempts to lock the mutex owned by this object without blocking.
>>> -// If the mutex is already locked, TryLock() will not block waiting
>>> -// for the mutex, but will return an error condition.
>>> -//
>>> -// RETURNS
>>> -// The error code from the pthread_mutex_trylock() function call.
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Mutex::TryLock(const char *failure_message)
>>> -{
>>> - return
>>> TryEnterCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex)) == 0;
>>> -}
>>> -
>>> -//----------------------------------------------------------------------
>>> -// If the current thread holds the lock on the owned mutex, then
>>> -// Unlock() will unlock the mutex. Calling Unlock() on this object
>>> -// that the calling thread does not hold will result in undefined
>>> -// behavior.
>>> -//
>>> -// RETURNS
>>> -// The error code from the pthread_mutex_unlock() function call.
>>> -//----------------------------------------------------------------------
>>> -int
>>> -Mutex::Unlock()
>>> -{
>>> - LeaveCriticalSection(static_cast<PCRITICAL_SECTION>(m_mutex));
>>> - return 0;
>>> -}
>>>
>>> Modified:
>>> lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> ---
>>> lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h
>>> (original)
>>> +++
>>> lldb/trunk/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h
>>> Thu Jul 28 12:32:20 2016
>>> @@ -22,7 +22,6 @@
>>> #include "lldb/Host/FileSpec.h"
>>> #include "lldb/Core/StructuredData.h"
>>> #include "lldb/Core/UUID.h"
>>> -#include "lldb/Host/Mutex.h"
>>> #include "lldb/Target/Process.h"
>>> #include "lldb/Utility/SafeMachO.h"
>>>
>>>
>>> Modified: lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp (original)
>>> +++ lldb/trunk/source/Plugins/Platform/Linux/PlatformLinux.cpp Thu Jul
>>> 28 12:32:20 2016
>>> @@ -699,7 +699,8 @@ PlatformLinux::DebugProcess (ProcessLaun
>>> // Handle the hijacking of process events.
>>> if (listener_sp)
>>> {
>>> - const StateType state = process_sp->WaitForProcessToStop
>>> (NULL, NULL, false, listener_sp);
>>> + const StateType state =
>>> +
>>> process_sp->WaitForProcessToStop(std::chrono::microseconds(0), NULL, false,
>>> listener_sp);
>>>
>>> if (state == eStateStopped)
>>> {
>>>
>>> Modified:
>>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
>>> (original)
>>> +++ lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
>>> Thu Jul 28 12:32:20 2016
>>> @@ -210,11 +210,10 @@ CommunicationKDP::GetSequenceMutex(std::
>>> return (lock =
>>> std::unique_lock<std::recursive_mutex>(m_sequence_mutex,
>>> std::try_to_lock)).owns_lock();
>>> }
>>>
>>> -
>>> bool
>>> -CommunicationKDP::WaitForNotRunningPrivate (const TimeValue
>>> *timeout_ptr)
>>> +CommunicationKDP::WaitForNotRunningPrivate(const
>>> std::chrono::microseconds &timeout)
>>> {
>>> - return m_is_running.WaitForValueEqualTo (false, timeout_ptr, NULL);
>>> + return m_is_running.WaitForValueEqualTo(false, timoeut, NULL);
>>> }
>>>
>>> size_t
>>>
>>> Modified:
>>> lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h
>>> (original)
>>> +++ lldb/trunk/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h
>>> Thu Jul 28 12:32:20 2016
>>> @@ -249,7 +249,7 @@ protected:
>>> uint32_t timeout_usec);
>>>
>>> bool
>>> - WaitForNotRunningPrivate (const lldb_private::TimeValue
>>> *timeout_ptr);
>>> + WaitForNotRunningPrivate(const std::chrono::microseconds &timeout);
>>>
>>> void
>>> MakeRequestPacketHeader (CommandType request_type,
>>>
>>> Modified: lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp
>>> (original)
>>> +++ lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp Thu
>>> Jul 28 12:32:20 2016
>>> @@ -941,7 +941,7 @@ ProcessKDP::AsyncThread (void *arg)
>>> if (log)
>>> log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64
>>> ") listener.WaitForEvent (NULL, event_sp)...",
>>> pid);
>>> - if (listener_sp->WaitForEvent (NULL, event_sp))
>>> + if (listener_sp->WaitForEvent(stsd::chrono::micrseconds(0),
>>> event_sp))
>>> {
>>> uint32_t event_type = event_sp->GetType();
>>> if (log)
>>>
>>> Modified:
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> ---
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
>>> (original)
>>> +++
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp Thu
>>> Jul 28 12:32:20 2016
>>> @@ -152,23 +152,22 @@ GDBRemoteCommunication::History::Dump (L
>>> //----------------------------------------------------------------------
>>> // GDBRemoteCommunication constructor
>>> //----------------------------------------------------------------------
>>> -GDBRemoteCommunication::GDBRemoteCommunication(const char *comm_name,
>>> - const char
>>> *listener_name) :
>>> - Communication(comm_name),
>>> +GDBRemoteCommunication::GDBRemoteCommunication(const char *comm_name,
>>> const char *listener_name)
>>> + : Communication(comm_name),
>>> #ifdef LLDB_CONFIGURATION_DEBUG
>>> - m_packet_timeout (1000),
>>> + m_packet_timeout(1000),
>>> #else
>>> - m_packet_timeout (1),
>>> + m_packet_timeout(1),
>>> #endif
>>> - m_echo_number(0),
>>> - m_supports_qEcho (eLazyBoolCalculate),
>>> - m_sequence_mutex (Mutex::eMutexTypeRecursive),
>>> - m_public_is_running (false),
>>> - m_private_is_running (false),
>>> - m_history (512),
>>> - m_send_acks (true),
>>> - m_compression_type (CompressionType::None),
>>> - m_listen_url ()
>>> + m_echo_number(0),
>>> + m_supports_qEcho(eLazyBoolCalculate),
>>> + m_sequence_mutex(),
>>> + m_public_is_running(false),
>>> + m_private_is_running(false),
>>> + m_history(512),
>>> + m_send_acks(true),
>>> + m_compression_type(CompressionType::None),
>>> + m_listen_url()
>>> {
>>> }
>>>
>>> @@ -229,7 +228,7 @@ GDBRemoteCommunication::SendNack ()
>>> GDBRemoteCommunication::PacketResult
>>> GDBRemoteCommunication::SendPacket (const char *payload, size_t
>>> payload_length)
>>> {
>>> - Mutex::Locker locker(m_sequence_mutex);
>>> + std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
>>> return SendPacketNoLock (payload, payload_length);
>>> }
>>>
>>> @@ -323,20 +322,19 @@ GDBRemoteCommunication::GetAck ()
>>> }
>>>
>>> bool
>>> -GDBRemoteCommunication::GetSequenceMutex (Mutex::Locker& locker, const
>>> char *failure_message)
>>> +GDBRemoteCommunication::GetSequenceMutex(std::unique_lock<std::recursive_mutex>
>>> &lock, const char *failure_message)
>>> {
>>> if (IsRunning())
>>> - return locker.TryLock (m_sequence_mutex, failure_message);
>>> + return (lock =
>>> std::unique_lock<std::recursive_mutex>(m_sequence_mutex,
>>> std::try_to_lock)).owns_lock();
>>>
>>> - locker.Lock (m_sequence_mutex);
>>> + lock = std::unique_lock<std::recursive_mutex>(m_sequence_mutex);
>>> return true;
>>> }
>>>
>>> -
>>> bool
>>> -GDBRemoteCommunication::WaitForNotRunningPrivate (const TimeValue
>>> *timeout_ptr)
>>> +GDBRemoteCommunication::WaitForNotRunningPrivate(const
>>> std::chrono::microseconds &timeout)
>>> {
>>> - return m_private_is_running.WaitForValueEqualTo (false,
>>> timeout_ptr, NULL);
>>> + return m_private_is_running.WaitForValueEqualTo(false, timeout,
>>> NULL);
>>> }
>>>
>>> GDBRemoteCommunication::PacketResult
>>> @@ -356,20 +354,22 @@ GDBRemoteCommunication::ReadPacket (Stri
>>> GDBRemoteCommunication::PacketResult
>>> GDBRemoteCommunication::PopPacketFromQueue (StringExtractorGDBRemote
>>> &response, uint32_t timeout_usec)
>>> {
>>> - // Calculate absolute timeout value
>>> - TimeValue timeout = TimeValue::Now();
>>> - timeout.OffsetWithMicroSeconds(timeout_usec);
>>> + auto until = std::chrono::system_clock::now() +
>>> std::chrono::microseconds(timeout_usec);
>>>
>>> - do
>>> + while (true)
>>> {
>>> // scope for the mutex
>>> {
>>> // lock down the packet queue
>>> - Mutex::Locker locker(m_packet_queue_mutex);
>>> + std::unique_lock<std::mutex> lock(m_packet_queue_mutex);
>>>
>>> // Wait on condition variable.
>>> if (m_packet_queue.size() == 0)
>>> - m_condition_queue_not_empty.Wait(m_packet_queue_mutex,
>>> &timeout);
>>> + {
>>> + std::cv_status result =
>>> m_condition_queue_not_empty.wait_until(lock, until);
>>> + if (result == std::cv_status::timeout)
>>> + break;
>>> + }
>>>
>>> if (m_packet_queue.size() > 0)
>>> {
>>> @@ -389,7 +389,7 @@ GDBRemoteCommunication::PopPacketFromQue
>>> return PacketResult::ErrorDisconnected;
>>>
>>> // Loop while not timed out
>>> - } while (TimeValue::Now() < timeout);
>>> + }
>>>
>>> return PacketResult::ErrorReplyTimeout;
>>> }
>>> @@ -1479,12 +1479,11 @@ void GDBRemoteCommunication::AppendBytes
>>> // scope for the mutex
>>> {
>>> // lock down the packet queue
>>> - Mutex::Locker locker(m_packet_queue_mutex);
>>> + std::lock_guard<std::mutex> guard(m_packet_queue_mutex);
>>> // push a new packet into the queue
>>> m_packet_queue.push(packet);
>>> // Signal condition variable that we have a packet
>>> - m_condition_queue_not_empty.Signal();
>>> -
>>> + m_condition_queue_not_empty.notify_one();
>>> }
>>> }
>>>
>>>
>>> Modified:
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> ---
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
>>> (original)
>>> +++
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h Thu
>>> Jul 28 12:32:20 2016
>>> @@ -12,6 +12,8 @@
>>>
>>> // C Includes
>>> // C++ Includes
>>> +#include <condition_variable>
>>> +#include <mutex>
>>> #include <string>
>>> #include <queue>
>>> #include <vector>
>>> @@ -22,7 +24,6 @@
>>> #include "lldb/Core/Communication.h"
>>> #include "lldb/Core/Listener.h"
>>> #include "lldb/Host/HostThread.h"
>>> -#include "lldb/Host/Mutex.h"
>>> #include "lldb/Host/Predicate.h"
>>> #include "lldb/Host/TimeValue.h"
>>> #include "lldb/Interpreter/Args.h"
>>> @@ -114,7 +115,7 @@ public:
>>> size_t payload_length);
>>>
>>> bool
>>> - GetSequenceMutex(Mutex::Locker& locker, const char *failure_message
>>> = nullptr);
>>> + GetSequenceMutex(std::unique_lock<std::recursive_mutex> &lock,
>>> const char *failure_message = nullptr);
>>>
>>> PacketType
>>> CheckForPacket (const uint8_t *src,
>>> @@ -285,9 +286,9 @@ protected:
>>> uint32_t m_echo_number;
>>> LazyBool m_supports_qEcho;
>>> #ifdef ENABLE_MUTEX_ERROR_CHECKING
>>> - TrackingMutex m_sequence_mutex;
>>> +#error TrackingMutex is no longer supported
>>> #else
>>> - Mutex m_sequence_mutex; // Restrict access to sending/receiving
>>> packets to a single thread at a time
>>> + std::recursive_mutex m_sequence_mutex; // Restrict access to
>>> sending/receiving packets to a single thread at a time
>>> #endif
>>> Predicate<bool> m_public_is_running;
>>> Predicate<bool> m_private_is_running;
>>> @@ -320,7 +321,7 @@ protected:
>>> bool sync_on_timeout);
>>>
>>> bool
>>> - WaitForNotRunningPrivate (const TimeValue *timeout_ptr);
>>> + WaitForNotRunningPrivate(const std::chrono::microseconds &timeout);
>>>
>>> bool
>>> CompressionIsEnabled ()
>>> @@ -364,8 +365,8 @@ protected:
>>>
>>> private:
>>> std::queue<StringExtractorGDBRemote> m_packet_queue; // The packet
>>> queue
>>> - lldb_private::Mutex m_packet_queue_mutex; // Mutex for
>>> accessing queue
>>> - Condition m_condition_queue_not_empty; // Condition
>>> variable to wait for packets
>>> + std::mutex m_packet_queue_mutex; // Mutex for
>>> accessing queue
>>> + std::condition_variable m_condition_queue_not_empty; // Condition
>>> variable to wait for packets
>>>
>>> HostThread m_listen_thread;
>>> std::string m_listen_url;
>>>
>>> Modified:
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> ---
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
>>> (original)
>>> +++
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
>>> Thu Jul 28 12:32:20 2016
>>> @@ -720,9 +720,10 @@ GDBRemoteCommunicationClient::SendPacket
>>> std::string &response_string
>>> )
>>> {
>>> - Mutex::Locker locker;
>>> - if (!GetSequenceMutex(locker,
>>> -
>>> "ProcessGDBRemote::SendPacketsAndConcatenateResponses() failed due to not
>>> getting the sequence mutex"))
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (!GetSequenceMutex(
>>> + lock,
>>> + "ProcessGDBRemote::SendPacketsAndConcatenateResponses()
>>> failed due to not getting the sequence mutex"))
>>> {
>>> Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet
>>> (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
>>> if (log)
>>> @@ -821,7 +822,7 @@ GDBRemoteCommunicationClient::SendPacket
>>> )
>>> {
>>> PacketResult packet_result = PacketResult::ErrorSendFailed;
>>> - Mutex::Locker locker;
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet
>>> (GDBR_LOG_PROCESS));
>>>
>>> // In order to stop async notifications from being processed in the
>>> middle of the
>>> @@ -829,7 +830,7 @@ GDBRemoteCommunicationClient::SendPacket
>>> static ListenerSP
>>> hijack_listener_sp(Listener::MakeListener("lldb.NotifyHijacker"));
>>> HijackBroadcaster(hijack_listener_sp,
>>> eBroadcastBitGdbReadThreadGotNotify);
>>>
>>> - if (GetSequenceMutex (locker))
>>> + if (GetSequenceMutex(lock))
>>> {
>>> packet_result = SendPacketAndWaitForResponseNoLock (payload,
>>> payload_length, response);
>>> }
>>> @@ -848,19 +849,22 @@ GDBRemoteCommunicationClient::SendPacket
>>> log->Printf ("async: async packet = %s",
>>> m_async_packet.c_str());
>>>
>>> bool timed_out = false;
>>> - if (SendInterrupt(locker, 2, timed_out))
>>> + if (SendInterrupt(lock, 2, timed_out))
>>> {
>>> if (m_interrupt_sent)
>>> {
>>> m_interrupt_sent = false;
>>> - TimeValue timeout_time;
>>> - timeout_time = TimeValue::Now();
>>> - timeout_time.OffsetWithSeconds
>>> (m_packet_timeout);
>>> +
>>> +
>>> std::chrono::time_point<std::chrono::system_clock> until;
>>> + until = std::chrono::system_clock::now() +
>>> std::chrono::seconds(m_packet_timeout);
>>>
>>> if (log)
>>> log->Printf ("async: sent interrupt");
>>>
>>> - if
>>> (m_async_packet_predicate.WaitForValueEqualTo (false, &timeout_time,
>>> &timed_out))
>>> + if
>>> (m_async_packet_predicate.WaitForValueEqualTo(
>>> + false,
>>> std::chrono::duration_cast<std::chrono::microseconds>(
>>> + until -
>>> std::chrono::system_clock::now()),
>>> + &timed_out))
>>> {
>>> if (log)
>>> log->Printf ("async: got response");
>>> @@ -876,7 +880,10 @@ GDBRemoteCommunicationClient::SendPacket
>>> }
>>>
>>> // Make sure we wait until the continue packet
>>> has been sent again...
>>> - if (m_private_is_running.WaitForValueEqualTo
>>> (true, &timeout_time, &timed_out))
>>> + if (m_private_is_running.WaitForValueEqualTo(
>>> + true,
>>> std::chrono::duration_cast<std::chrono::microseconds>(
>>> + until -
>>> std::chrono::system_clock::now()),
>>> + &timed_out))
>>> {
>>> if (log)
>>> {
>>> @@ -1045,7 +1052,7 @@ GDBRemoteCommunicationClient::SendvContP
>>> log->Printf("GDBRemoteCommunicationClient::%s ()",
>>> __FUNCTION__);
>>>
>>> // we want to lock down packet sending while we continue
>>> - Mutex::Locker locker(m_sequence_mutex);
>>> + std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
>>>
>>> // here we broadcast this before we even send the packet!!
>>> // this signals doContinue() to exit
>>> @@ -1094,7 +1101,7 @@ GDBRemoteCommunicationClient::SendContin
>>> if (log)
>>> log->Printf ("GDBRemoteCommunicationClient::%s ()",
>>> __FUNCTION__);
>>>
>>> - Mutex::Locker locker(m_sequence_mutex);
>>> + std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
>>> StateType state = eStateRunning;
>>>
>>> m_public_is_running.SetValue (true, eBroadcastNever);
>>> @@ -1394,8 +1401,8 @@ GDBRemoteCommunicationClient::SendAsyncS
>>> std::lock_guard<std::recursive_mutex> guard(m_async_mutex);
>>> m_async_signal = signo;
>>> bool timed_out = false;
>>> - Mutex::Locker locker;
>>> - if (SendInterrupt (locker, 1, timed_out))
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (SendInterrupt(lock, 1, timed_out))
>>> return true;
>>> m_async_signal = -1;
>>> return false;
>>> @@ -1412,12 +1419,8 @@ GDBRemoteCommunicationClient::SendAsyncS
>>> // (gdb remote protocol requires this), and do what we need to do, then
>>> resume.
>>>
>>> bool
>>> -GDBRemoteCommunicationClient::SendInterrupt
>>> -(
>>> - Mutex::Locker& locker,
>>> - uint32_t seconds_to_wait_for_stop,
>>> - bool &timed_out
>>> -)
>>> +GDBRemoteCommunicationClient::SendInterrupt(std::unique_lock<std::recursive_mutex>
>>> &lock,
>>> + uint32_t
>>> seconds_to_wait_for_stop, bool &timed_out)
>>> {
>>> timed_out = false;
>>> Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet
>>> (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
>>> @@ -1425,7 +1428,7 @@ GDBRemoteCommunicationClient::SendInterr
>>> if (IsRunning())
>>> {
>>> // Only send an interrupt if our debugserver is running...
>>> - if (GetSequenceMutex (locker))
>>> + if (GetSequenceMutex(lock))
>>> {
>>> if (log)
>>> log->Printf ("SendInterrupt () - got sequence mutex
>>> without having to interrupt");
>>> @@ -1444,13 +1447,8 @@ GDBRemoteCommunicationClient::SendInterr
>>> m_interrupt_sent = true;
>>> if (seconds_to_wait_for_stop)
>>> {
>>> - TimeValue timeout;
>>> - if (seconds_to_wait_for_stop)
>>> - {
>>> - timeout = TimeValue::Now();
>>> - timeout.OffsetWithSeconds
>>> (seconds_to_wait_for_stop);
>>> - }
>>> - if (m_private_is_running.WaitForValueEqualTo
>>> (false, &timeout, &timed_out))
>>> + if (m_private_is_running.WaitForValueEqualTo(false,
>>> std::chrono::seconds(seconds_to_wait_for_stop),
>>> +
>>> &timed_out))
>>> {
>>> if (log)
>>> log->PutCString ("SendInterrupt () - sent
>>> interrupt, private state stopped");
>>> @@ -3653,10 +3651,10 @@ size_t
>>> GDBRemoteCommunicationClient::GetCurrentThreadIDs
>>> (std::vector<lldb::tid_t> &thread_ids,
>>> bool
>>> &sequence_mutex_unavailable)
>>> {
>>> - Mutex::Locker locker;
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> thread_ids.clear();
>>> -
>>> - if (GetSequenceMutex (locker, "ProcessGDBRemote::UpdateThreadList()
>>> failed due to not getting the sequence mutex"))
>>> +
>>> + if (GetSequenceMutex(lock, "ProcessGDBRemote::UpdateThreadList()
>>> failed due to not getting the sequence mutex"))
>>> {
>>> sequence_mutex_unavailable = false;
>>> StringExtractorGDBRemote response;
>>> @@ -4203,8 +4201,8 @@ GDBRemoteCommunicationClient::AvoidGPack
>>> bool
>>> GDBRemoteCommunicationClient::ReadRegister(lldb::tid_t tid, uint32_t
>>> reg, StringExtractorGDBRemote &response)
>>> {
>>> - Mutex::Locker locker;
>>> - if (GetSequenceMutex (locker, "Didn't get sequence mutex for p
>>> packet."))
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (GetSequenceMutex(lock, "Didn't get sequence mutex for p
>>> packet."))
>>> {
>>> const bool thread_suffix_supported = GetThreadSuffixSupported();
>>>
>>> @@ -4228,8 +4226,8 @@ GDBRemoteCommunicationClient::ReadRegist
>>> bool
>>> GDBRemoteCommunicationClient::ReadAllRegisters (lldb::tid_t tid,
>>> StringExtractorGDBRemote &response)
>>> {
>>> - Mutex::Locker locker;
>>> - if (GetSequenceMutex (locker, "Didn't get sequence mutex for g
>>> packet."))
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (GetSequenceMutex(lock, "Didn't get sequence mutex for g
>>> packet."))
>>> {
>>> const bool thread_suffix_supported = GetThreadSuffixSupported();
>>>
>>> @@ -4256,8 +4254,8 @@ GDBRemoteCommunicationClient::SaveRegist
>>> return false;
>>>
>>> m_supports_QSaveRegisterState = eLazyBoolYes;
>>> - Mutex::Locker locker;
>>> - if (GetSequenceMutex (locker, "Didn't get sequence mutex for
>>> QSaveRegisterState."))
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (GetSequenceMutex(lock, "Didn't get sequence mutex for
>>> QSaveRegisterState."))
>>> {
>>> const bool thread_suffix_supported = GetThreadSuffixSupported();
>>> if (thread_suffix_supported || SetCurrentThread(tid))
>>> @@ -4298,9 +4296,9 @@ GDBRemoteCommunicationClient::RestoreReg
>>> // order to be useful
>>> if (m_supports_QSaveRegisterState == eLazyBoolNo)
>>> return false;
>>> -
>>> - Mutex::Locker locker;
>>> - if (GetSequenceMutex (locker, "Didn't get sequence mutex for
>>> QRestoreRegisterState."))
>>> +
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (GetSequenceMutex(lock, "Didn't get sequence mutex for
>>> QRestoreRegisterState."))
>>> {
>>> const bool thread_suffix_supported = GetThreadSuffixSupported();
>>> if (thread_suffix_supported || SetCurrentThread(tid))
>>> @@ -4530,8 +4528,10 @@ GDBRemoteCommunicationClient::ServeSymbo
>>>
>>> if (m_supports_qSymbol && m_qSymbol_requests_done == false)
>>> {
>>> - Mutex::Locker locker;
>>> - if (GetSequenceMutex(locker,
>>> "GDBRemoteCommunicationClient::ServeSymbolLookups() failed due to not
>>> getting the sequence mutex"))
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (GetSequenceMutex(
>>> + lock,
>>> + "GDBRemoteCommunicationClient::ServeSymbolLookups()
>>> failed due to not getting the sequence mutex"))
>>> {
>>> StreamString packet;
>>> packet.PutCString ("qSymbol::");
>>>
>>> Modified:
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> ---
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
>>> (original)
>>> +++
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
>>> Thu Jul 28 12:32:20 2016
>>> @@ -105,9 +105,7 @@ public:
>>> SendAsyncSignal (int signo);
>>>
>>> bool
>>> - SendInterrupt (Mutex::Locker &locker,
>>> - uint32_t seconds_to_wait_for_stop,
>>> - bool &timed_out);
>>> + SendInterrupt(std::unique_lock<std::recursive_mutex> &lock,
>>> uint32_t seconds_to_wait_for_stop, bool &timed_out);
>>>
>>> lldb::pid_t
>>> GetCurrentProcessID (bool allow_lazy = true);
>>>
>>> Modified:
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> ---
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
>>> (original)
>>> +++
>>> lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
>>> Thu Jul 28 12:32:20 2016
>>> @@ -401,8 +401,8 @@ GDBRemoteRegisterContext::WriteRegisterB
>>> reg_info->byte_size, // dst
>>> length
>>> m_reg_data.GetByteOrder())) // dst
>>> byte order
>>> {
>>> - Mutex::Locker locker;
>>> - if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence
>>> mutex for write register."))
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (gdb_comm.GetSequenceMutex(lock, "Didn't get sequence mutex
>>> for write register."))
>>> {
>>> const bool thread_suffix_supported =
>>> gdb_comm.GetThreadSuffixSupported();
>>> ProcessSP process_sp (m_thread.GetProcess());
>>> @@ -570,8 +570,8 @@ GDBRemoteRegisterContext::ReadAllRegiste
>>>
>>> const bool use_g_packet = gdb_comm.AvoidGPackets ((ProcessGDBRemote
>>> *)process) == false;
>>>
>>> - Mutex::Locker locker;
>>> - if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex
>>> for read all registers."))
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (gdb_comm.GetSequenceMutex(lock, "Didn't get sequence mutex for
>>> read all registers."))
>>> {
>>> SyncThreadState(process);
>>>
>>> @@ -679,8 +679,8 @@ GDBRemoteRegisterContext::WriteAllRegist
>>> const bool use_g_packet = gdb_comm.AvoidGPackets ((ProcessGDBRemote
>>> *)process) == false;
>>>
>>> StringExtractorGDBRemote response;
>>> - Mutex::Locker locker;
>>> - if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex
>>> for write all registers."))
>>> + std::unique_lock<std::recursive_mutex> lock;
>>> + if (gdb_comm.GetSequenceMutex(lock, "Didn't get sequence mutex for
>>> write all registers."))
>>> {
>>> const bool thread_suffix_supported =
>>> gdb_comm.GetThreadSuffixSupported();
>>> ProcessSP process_sp (m_thread.GetProcess());
>>>
>>> Modified:
>>> lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
>>> (original)
>>> +++ lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
>>> Thu Jul 28 12:32:20 2016
>>> @@ -1590,9 +1590,6 @@ ProcessGDBRemote::DoResume ()
>>> else
>>> {
>>> EventSP event_sp;
>>> - TimeValue timeout;
>>> - timeout = TimeValue::Now();
>>> - timeout.OffsetWithSeconds (5);
>>> if (!m_async_thread.IsJoinable())
>>> {
>>> error.SetErrorString ("Trying to resume but the async
>>> thread is dead.");
>>> @@ -1603,7 +1600,7 @@ ProcessGDBRemote::DoResume ()
>>>
>>> m_async_broadcaster.BroadcastEvent
>>> (eBroadcastBitAsyncContinue, new EventDataBytes (continue_packet.GetData(),
>>> continue_packet.GetSize()));
>>>
>>> - if (listener_sp->WaitForEvent (&timeout, event_sp) == false)
>>> + if (listener_sp->WaitForEvent(std::chrono::seconds(5),
>>> event_sp) == false)
>>> {
>>> error.SetErrorString("Resume timed out.");
>>> if (log)
>>> @@ -2717,7 +2714,7 @@ ProcessGDBRemote::DoHalt (bool &caused_s
>>> Error error;
>>>
>>> bool timed_out = false;
>>> - Mutex::Locker locker;
>>> + std::unique_lock<std::recursive_mutex> lock;
>>>
>>> if (m_public_state.GetValue() == eStateAttaching)
>>> {
>>> @@ -2727,7 +2724,7 @@ ProcessGDBRemote::DoHalt (bool &caused_s
>>> }
>>> else
>>> {
>>> - if (!m_gdb_comm.SendInterrupt (locker, 2, timed_out))
>>> + if (!m_gdb_comm.SendInterrupt(lock, 2, timed_out))
>>> {
>>> if (timed_out)
>>> error.SetErrorString("timed out sending interrupt
>>> packet");
>>> @@ -3860,7 +3857,7 @@ ProcessGDBRemote::AsyncThread (void *arg
>>> {
>>> if (log)
>>> log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %"
>>> PRIu64 ") listener.WaitForEvent (NULL, event_sp)...", __FUNCTION__, arg,
>>> process->GetID());
>>> - if (process->m_async_listener_sp->WaitForEvent (NULL, event_sp))
>>> + if
>>> (process->m_async_listener_sp->WaitForEvent(std::chrono::microseconds(0),
>>> event_sp))
>>> {
>>> const uint32_t event_type = event_sp->GetType();
>>> if (event_sp->BroadcasterIs (&process->m_async_broadcaster))
>>>
>>> Modified: lldb/trunk/source/Target/Process.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Process.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Target/Process.cpp (original)
>>> +++ lldb/trunk/source/Target/Process.cpp Thu Jul 28 12:32:20 2016
>>> @@ -978,10 +978,8 @@ Process::SyncIOHandler (uint32_t iohandl
>>> if (!m_process_input_reader)
>>> return;
>>>
>>> - TimeValue timeout = TimeValue::Now();
>>> - timeout.OffsetWithMicroSeconds(timeout_msec*1000);
>>> uint32_t new_iohandler_id = 0;
>>> - m_iohandler_sync.WaitForValueNotEqualTo(iohandler_id,
>>> new_iohandler_id, &timeout);
>>> + m_iohandler_sync.WaitForValueNotEqualTo(iohandler_id,
>>> new_iohandler_id, std::chrono::milliseconds(timeout_msec));
>>>
>>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_PROCESS));
>>> if (log)
>>> @@ -989,12 +987,8 @@ Process::SyncIOHandler (uint32_t iohandl
>>> }
>>>
>>> StateType
>>> -Process::WaitForProcessToStop (const TimeValue *timeout,
>>> - EventSP *event_sp_ptr,
>>> - bool wait_always,
>>> - ListenerSP hijack_listener_sp,
>>> - Stream *stream,
>>> - bool use_run_lock)
>>> +Process::WaitForProcessToStop(const std::chrono::microseconds &timeout,
>>> EventSP *event_sp_ptr, bool wait_always,
>>> + ListenerSP hijack_listener_sp, Stream
>>> *stream, bool use_run_lock)
>>> {
>>> // We can't just wait for a "stopped" event, because the stopped
>>> event may have restarted the target.
>>> // We have to actually check each event, and in the case of a
>>> stopped event check the restarted flag
>>> @@ -1009,8 +1003,7 @@ Process::WaitForProcessToStop (const Tim
>>>
>>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_PROCESS));
>>> if (log)
>>> - log->Printf ("Process::%s (timeout = %p)", __FUNCTION__,
>>> - static_cast<const void*>(timeout));
>>> + log->Printf("Process::%s (timeout = %llu)", __FUNCTION__,
>>> static_cast<unsigned long long>(timeout.count()));
>>>
>>> if (!wait_always &&
>>> StateIsStoppedState(state, true) &&
>>> @@ -1029,7 +1022,7 @@ Process::WaitForProcessToStop (const Tim
>>> while (state != eStateInvalid)
>>> {
>>> EventSP event_sp;
>>> - state = WaitForStateChangedEvents (timeout, event_sp,
>>> hijack_listener_sp);
>>> + state = WaitForStateChangedEvents(std::chrono::milliseconds(0),
>>> event_sp, hijack_listener_sp);
>>> if (event_sp_ptr && event_sp)
>>> *event_sp_ptr = event_sp;
>>>
>>> @@ -1265,8 +1258,7 @@ Process::HandleProcessStateChangedEvent
>>> }
>>>
>>> StateType
>>> -Process::WaitForState(const TimeValue *timeout,
>>> - const StateType *match_states,
>>> +Process::WaitForState(const std::chrono::microseconds &timeout, const
>>> StateType *match_states,
>>> const uint32_t num_match_states)
>>> {
>>> EventSP event_sp;
>>> @@ -1307,13 +1299,14 @@ Process::RestoreProcessEvents ()
>>> }
>>>
>>> StateType
>>> -Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP
>>> &event_sp, ListenerSP hijack_listener_sp)
>>> +Process::WaitForStateChangedEvents(const std::chrono::microseconds
>>> &timeout, EventSP &event_sp,
>>> + ListenerSP hijack_listener_sp)
>>> {
>>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_PROCESS));
>>>
>>> if (log)
>>> - log->Printf ("Process::%s (timeout = %p, event_sp)...",
>>> __FUNCTION__,
>>> - static_cast<const void*>(timeout));
>>> + log->Printf("Process::%s (timeout = %llu, event_sp)...",
>>> __FUNCTION__,
>>> + static_cast<unsigned long long>(timeout.count()));
>>>
>>> ListenerSP listener_sp = hijack_listener_sp;
>>> if (!listener_sp)
>>> @@ -1332,9 +1325,8 @@ Process::WaitForStateChangedEvents (cons
>>> }
>>>
>>> if (log)
>>> - log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
>>> - __FUNCTION__, static_cast<const void*>(timeout),
>>> - StateAsCString(state));
>>> + log->Printf("Process::%s (timeout = %llu, event_sp) => %s",
>>> __FUNCTION__,
>>> + static_cast<unsigned long long>(timeout.count()),
>>> StateAsCString(state));
>>> return state;
>>> }
>>>
>>> @@ -1367,13 +1359,13 @@ Process::PeekAtStateChangedEvents ()
>>> }
>>>
>>> StateType
>>> -Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout,
>>> EventSP &event_sp)
>>> +Process::WaitForStateChangedEventsPrivate(const
>>> std::chrono::microseconds &timeout, EventSP &event_sp)
>>> {
>>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_PROCESS));
>>>
>>> if (log)
>>> - log->Printf ("Process::%s (timeout = %p, event_sp)...",
>>> __FUNCTION__,
>>> - static_cast<const void*>(timeout));
>>> + log->Printf("Process::%s (timeout = %llu, event_sp)...",
>>> __FUNCTION__,
>>> + static_cast<unsigned long long>(timeout.count()));
>>>
>>> StateType state = eStateInvalid;
>>> if (m_private_state_listener_sp->WaitForEventForBroadcasterWithType
>>> (timeout,
>>> @@ -1387,20 +1379,20 @@ Process::WaitForStateChangedEventsPrivat
>>> // to the command-line, and that could disable the log, which would
>>> render the
>>> // log we got above invalid.
>>> if (log)
>>> - log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
>>> - __FUNCTION__, static_cast<const void *>(timeout),
>>> - state == eStateInvalid ? "TIMEOUT" :
>>> StateAsCString(state));
>>> + log->Printf("Process::%s (timeout = %llu, event_sp) => %s",
>>> __FUNCTION__,
>>> + static_cast<unsigned long long>(timeout.count()),
>>> + state == eStateInvalid ? "TIMEOUT" :
>>> StateAsCString(state));
>>> return state;
>>> }
>>>
>>> bool
>>> -Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP
>>> &event_sp, bool control_only)
>>> +Process::WaitForEventsPrivate(const std::chrono::microseconds &timeout,
>>> EventSP &event_sp, bool control_only)
>>> {
>>> Log *log(lldb_private::GetLogIfAllCategoriesSet
>>> (LIBLLDB_LOG_PROCESS));
>>>
>>> if (log)
>>> - log->Printf ("Process::%s (timeout = %p, event_sp)...",
>>> __FUNCTION__,
>>> - static_cast<const void*>(timeout));
>>> + log->Printf("Process::%s (timeout = %llu, event_sp)...",
>>> __FUNCTION__,
>>> + static_cast<unsigned long long>(timeout.count()));
>>>
>>> if (control_only)
>>> return
>>> m_private_state_listener_sp->WaitForEventForBroadcaster(timeout,
>>> &m_private_state_control_broadcaster, event_sp);
>>> @@ -1751,7 +1743,7 @@ Process::ResumeSynchronous (Stream *stre
>>> Error error = PrivateResume();
>>> if (error.Success())
>>> {
>>> - StateType state = WaitForProcessToStop (NULL, NULL, true,
>>> listener_sp, stream);
>>> + StateType state =
>>> WaitForProcessToStop(std::chrono::microseconds(0), NULL, true, listener_sp,
>>> stream);
>>> const bool must_be_alive = false; // eStateExited is ok, so
>>> this must be false
>>> if (!StateIsStoppedState(state, must_be_alive))
>>> error.SetErrorStringWithFormat("process not in stopped
>>> state after synchronous resume: %s", StateAsCString(state));
>>> @@ -2891,7 +2883,7 @@ Process::DisableWatchpoint (Watchpoint *
>>> }
>>>
>>> StateType
>>> -Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP
>>> &event_sp)
>>> +Process::WaitForProcessStopPrivate(const std::chrono::microseconds
>>> &timeout, EventSP &event_sp)
>>> {
>>> StateType state;
>>> // Now wait for the process to launch and return control to us, and
>>> then
>>> @@ -2987,10 +2979,7 @@ Process::Launch (ProcessLaunchInfo &laun
>>> else
>>> {
>>> EventSP event_sp;
>>> - TimeValue timeout_time;
>>> - timeout_time = TimeValue::Now();
>>> - timeout_time.OffsetWithSeconds(10);
>>> - StateType state =
>>> WaitForProcessStopPrivate(&timeout_time, event_sp);
>>> + StateType state =
>>> WaitForProcessStopPrivate(std::chrono::seconds(10), event_sp);
>>>
>>> if (state == eStateInvalid || !event_sp)
>>> {
>>> @@ -3083,7 +3072,7 @@ Process::LoadCore ()
>>>
>>> // Wait indefinitely for a stopped event since we just posted
>>> one above...
>>> lldb::EventSP event_sp;
>>> - listener_sp->WaitForEvent (nullptr, event_sp);
>>> + listener_sp->WaitForEvent(std::chrono::microseconds(0),
>>> event_sp);
>>> StateType state =
>>> ProcessEventData::GetStateFromEvent(event_sp.get());
>>>
>>> if (!StateIsStoppedState (state, false))
>>> @@ -3502,8 +3491,8 @@ Process::ConnectRemote (Stream *strm, co
>>> if (GetID() != LLDB_INVALID_PROCESS_ID)
>>> {
>>> EventSP event_sp;
>>> - StateType state = WaitForProcessStopPrivate(nullptr,
>>> event_sp);
>>> -
>>> + StateType state =
>>> WaitForProcessStopPrivate(std::chrono::microseconds(0), event_sp);
>>> +
>>> if (state == eStateStopped || state == eStateCrashed)
>>> {
>>> // If we attached and actually have a process on the
>>> other end, then
>>> @@ -3612,11 +3601,8 @@ Process::Halt (bool clear_thread_plans,
>>> }
>>>
>>> // Wait for 10 second for the process to stop.
>>> - TimeValue timeout_time;
>>> - timeout_time = TimeValue::Now();
>>> - timeout_time.OffsetWithSeconds(10);
>>> - StateType state = WaitForProcessToStop(&timeout_time, &event_sp,
>>> true, halt_listener_sp,
>>> - nullptr, use_run_lock);
>>> + StateType state =
>>> + WaitForProcessToStop(std::chrono::seconds(10), &event_sp, true,
>>> halt_listener_sp, nullptr, use_run_lock);
>>> RestoreProcessEvents();
>>>
>>> if (state == eStateInvalid || ! event_sp)
>>> @@ -3649,10 +3635,7 @@ Process::StopForDestroyOrDetach(lldb::Ev
>>> SendAsyncInterrupt();
>>>
>>> // Consume the interrupt event.
>>> - TimeValue timeout (TimeValue::Now());
>>> - timeout.OffsetWithSeconds(10);
>>> -
>>> - StateType state = WaitForProcessToStop (&timeout,
>>> &exit_event_sp, true, listener_sp);
>>> + StateType state =
>>> WaitForProcessToStop(std::chrono::seconds(10), &exit_event_sp, true,
>>> listener_sp);
>>>
>>> RestoreProcessEvents();
>>>
>>> @@ -4125,12 +4108,9 @@ Process::ControlPrivateStateThread (uint
>>> while (!receipt_received)
>>> {
>>> bool timed_out = false;
>>> - TimeValue timeout_time;
>>> - timeout_time = TimeValue::Now();
>>> - timeout_time.OffsetWithSeconds(2);
>>> // Check for a receipt for 2 seconds and then check if
>>> the private state
>>> // thread is still around.
>>> - receipt_received =
>>> event_receipt_sp->WaitForEventReceived (&timeout_time, &timed_out);
>>> + receipt_received =
>>> event_receipt_sp->WaitForEventReceived(std::chrono::seconds(2), &timed_out);
>>> if (!receipt_received)
>>> {
>>> // Check if the private state thread is still
>>> around. If it isn't then we are done waiting
>>> @@ -4326,7 +4306,7 @@ Process::RunPrivateStateThread (bool is_
>>> while (!exit_now)
>>> {
>>> EventSP event_sp;
>>> - WaitForEventsPrivate(nullptr, event_sp, control_only);
>>> + WaitForEventsPrivate(std::chrono::microseconds(0), event_sp,
>>> control_only);
>>> if
>>> (event_sp->BroadcasterIs(&m_private_state_control_broadcaster))
>>> {
>>> if (log)
>>> @@ -5351,9 +5331,6 @@ Process::RunThreadPlan(ExecutionContext
>>> lldb::EventSP event_sp;
>>> lldb::StateType stop_state = lldb::eStateInvalid;
>>>
>>> - TimeValue* timeout_ptr = nullptr;
>>> - TimeValue real_timeout;
>>> -
>>> bool before_first_timeout = true; // This is set to false the
>>> first time that we have to halt the target.
>>> bool do_resume = true;
>>> bool handle_running_event = true;
>>> @@ -5454,6 +5431,7 @@ Process::RunThreadPlan(ExecutionContext
>>> #endif
>>> TimeValue one_thread_timeout;
>>> TimeValue final_timeout;
>>> + std::chrono::microseconds timeout =
>>> std::chrono::microseconds(0);
>>>
>>> while (true)
>>> {
>>> @@ -5484,10 +5462,7 @@ Process::RunThreadPlan(ExecutionContext
>>> }
>>> }
>>>
>>> - TimeValue resume_timeout = TimeValue::Now();
>>> - resume_timeout.OffsetWithMicroSeconds(500000);
>>> -
>>> - got_event = listener_sp->WaitForEvent(&resume_timeout,
>>> event_sp);
>>> + got_event =
>>> listener_sp->WaitForEvent(std::chrono::microseconds(500000), event_sp);
>>> if (!got_event)
>>> {
>>> if (log)
>>> @@ -5552,33 +5527,16 @@ Process::RunThreadPlan(ExecutionContext
>>> if (before_first_timeout)
>>> {
>>> if (options.GetTryAllThreads())
>>> - {
>>> - one_thread_timeout = TimeValue::Now();
>>> -
>>> one_thread_timeout.OffsetWithMicroSeconds(one_thread_timeout_usec);
>>> - timeout_ptr = &one_thread_timeout;
>>> - }
>>> + timeout =
>>> std::chrono::microseconds(one_thread_timeout_usec);
>>> else
>>> - {
>>> - if (timeout_usec == 0)
>>> - timeout_ptr = nullptr;
>>> - else
>>> - {
>>> - final_timeout = TimeValue::Now();
>>> - final_timeout.OffsetWithMicroSeconds
>>> (timeout_usec);
>>> - timeout_ptr = &final_timeout;
>>> - }
>>> - }
>>> + timeout = std::chrono::microseconds(timeout_usec);
>>> }
>>> else
>>> {
>>> if (timeout_usec == 0)
>>> - timeout_ptr = nullptr;
>>> + timeout = std::chrono::microseconds(0);
>>> else
>>> - {
>>> - final_timeout = TimeValue::Now();
>>> - final_timeout.OffsetWithMicroSeconds
>>> (all_threads_timeout_usec);
>>> - timeout_ptr = &final_timeout;
>>> - }
>>> + timeout =
>>> std::chrono::microseconds(all_threads_timeout_usec);
>>> }
>>>
>>> do_resume = true;
>>> @@ -5589,11 +5547,15 @@ Process::RunThreadPlan(ExecutionContext
>>>
>>> if (log)
>>> {
>>> - if (timeout_ptr)
>>> + if (timeout.count())
>>> {
>>> - log->Printf ("Process::RunThreadPlan(): about to
>>> wait - now is %" PRIu64 " - endpoint is %" PRIu64,
>>> -
>>> TimeValue::Now().GetAsMicroSecondsSinceJan1_1970(),
>>> -
>>> timeout_ptr->GetAsMicroSecondsSinceJan1_1970());
>>> + log->Printf(
>>> + "Process::RunThreadPlan(): about to wait - now
>>> is %llu - endpoint is %llu",
>>> + static_cast<unsigned long
>>> long>(std::chrono::system_clock::now().time_since_epoch().count()),
>>> + static_cast<unsigned long long>(
>>> +
>>> std::chrono::time_point<std::chrono::system_clock,
>>> std::chrono::microseconds>(timeout)
>>> + .time_since_epoch()
>>> + .count()));
>>> }
>>> else
>>> {
>>> @@ -5611,7 +5573,7 @@ Process::RunThreadPlan(ExecutionContext
>>> }
>>> else
>>> #endif
>>> - got_event = listener_sp->WaitForEvent (timeout_ptr,
>>> event_sp);
>>> + got_event = listener_sp->WaitForEvent(timeout,
>>> event_sp);
>>>
>>> if (got_event)
>>> {
>>> @@ -5810,10 +5772,7 @@ Process::RunThreadPlan(ExecutionContext
>>> if (log)
>>> log->PutCString ("Process::RunThreadPlan():
>>> Halt succeeded.");
>>>
>>> - real_timeout = TimeValue::Now();
>>> - real_timeout.OffsetWithMicroSeconds(500000);
>>> -
>>> - got_event =
>>> listener_sp->WaitForEvent(&real_timeout, event_sp);
>>> + got_event =
>>> listener_sp->WaitForEvent(std::chrono::microseconds(500000), event_sp);
>>>
>>> if (got_event)
>>> {
>>>
>>> Modified: lldb/trunk/source/Target/Target.cpp
>>> URL:
>>> http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Target/Target.cpp?rev=277011&r1=277010&r2=277011&view=diff
>>>
>>> ==============================================================================
>>> --- lldb/trunk/source/Target/Target.cpp (original)
>>> +++ lldb/trunk/source/Target/Target.cpp Thu Jul 28 12:32:20 2016
>>> @@ -3103,8 +3103,9 @@ Target::Launch (ProcessLaunchInfo &launc
>>> m_process_sp->HijackProcessEvents(hijack_listener_sp);
>>> }
>>>
>>> - StateType state =
>>> m_process_sp->WaitForProcessToStop(nullptr, nullptr, false,
>>> hijack_listener_sp, nullptr);
>>> -
>>> + StateType state =
>>> m_process_sp->WaitForProcessToStop(std::chrono::microseconds(0), nullptr,
>>> false,
>>> +
>>> hijack_listener_sp, nullptr);
>>> +
>>> if (state == eStateStopped)
>>> {
>>> if
>>> (!launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
>>> @@ -3114,7 +3115,8 @@ Target::Launch (ProcessLaunchInfo &launc
>>> error = m_process_sp->PrivateResume();
>>> if (error.Success())
>>> {
>>> - state =
>>> m_process_sp->WaitForProcessToStop(nullptr, nullptr, true,
>>> hijack_listener_sp, stream);
>>> + state =
>>> m_process_sp->WaitForProcessToStop(std::chrono::microseconds(0), nullptr,
>>> true,
>>> +
>>> hijack_listener_sp, stream);
>>> const bool must_be_alive = false; //
>>> eStateExited is ok, so this must be false
>>> if (!StateIsStoppedState(state,
>>> must_be_alive))
>>> {
>>> @@ -3243,7 +3245,8 @@ Target::Attach (ProcessAttachInfo &attac
>>> }
>>> else
>>> {
>>> - state = process_sp->WaitForProcessToStop (nullptr, nullptr,
>>> false, attach_info.GetHijackListener(), stream);
>>> + state =
>>> process_sp->WaitForProcessToStop(std::chrono::microseconds(0), nullptr,
>>> false,
>>> +
>>> attach_info.GetHijackListener(), stream);
>>> process_sp->RestoreProcessEvents ();
>>>
>>> if (state != eStateStopped)
>>>
>>>
>>> _______________________________________________
>>> lldb-commits mailing list
>>> lldb-commits at lists.llvm.org
>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
>>>
>>
>>
>>
>> --
>> -Todd
>>
>
>
>
> --
> -Todd
>
--
-Todd
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/lldb-dev/attachments/20160728/bcb953d0/attachment-0001.html>
More information about the lldb-dev
mailing list