[Lldb-commits] [lldb] r277011 - Clean up vestigial remnants of locking primitives
Saleem Abdulrasool via lldb-commits
lldb-commits at lists.llvm.org
Thu Jul 28 10:32:20 PDT 2016
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)
More information about the lldb-commits
mailing list