Move Predicate.h from Host to Utility

[labath]

Summary

This class was initially in Host because its implementation used to be
very OS-specific. However, with C++11, it has become a very simple
std::condition_variable wrapper, with no host-specific code.

It is also a general purpose utility class, so it makes sense for it to
live in a place where it can be used by everyone.

This has no effect on the layering right now, but it enables me to later
move the Listener+Broadcaster+Event combo to a lower layer, which is
important, as these are used in a lot of places (notably for launching a
process in Host code).

[xiaobai]

Hurray for more layering improvements!

It looks like Raphael recently committed a modulemap for compiling the LLDB headers into C++ modules (include/lldb/module.modulemap) that has a reference to Predicate.h in in Host. You should probably modify that as well.

[labath]

Updating the module map too (thanks).

[zturner]

lgtm, although Predicate is simple enough that I wonder if one day we should try to just delete it entirely.

[teemperor]

Is this blocked by something? If you're busy @labath I can commit this and watch the bots.

[labath]

Not blocked on anything, just haven't gotten around to committing it yet. Feel free to land it for me.

[labath]

Also, to answer Zachary's question:

A lot of the existing uses of Predicate class could be replaced by std::future (often future<void>). The one in the Event class is in this category. However, there are some uses (these tend to be hacks of various magnitudes), which are not as easy to replace.

include/lldb/Core/Event.h

 //===-- Event.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_Event_h_
 #define liblldb_Event_h_
 
 #include "lldb/Core/Broadcaster.h"
-#include "lldb/Host/Predicate.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-defines.h" // for DISALLOW_COPY_AND_ASSIGN
 #include "lldb/lldb-forward.h" // for EventDataSP, ProcessSP, Struct...
 
 #include "llvm/ADT/StringRef.h" // for StringRef
 
 #include <chrono>
 #include <memory>

include/lldb/Core/IOHandler.h

 //===-- IOHandler.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_IOHandler_h_
 #define liblldb_IOHandler_h_
 
 #include "lldb/Core/ValueObjectList.h"
-#include "lldb/Host/Predicate.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
+#include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-defines.h"  // for DISALLOW_COPY_AND_ASSIGN
 #include "lldb/lldb-forward.h"  // for IOHandlerSP, StreamFileSP
 #include "llvm/ADT/StringRef.h" // for StringRef
 
 #include <memory>
 #include <mutex>

include/lldb/Host/Editline.h

 #include <histedit.h>
 #endif
 
 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
-#include "lldb/Host/Predicate.h"
 #include "lldb/Utility/FileSpec.h"
+#include "lldb/Utility/Predicate.h"
 
 namespace lldb_private {
 namespace line_editor {
 
 // type alias's to help manage 8 bit and wide character versions of libedit
 #if LLDB_EDITLINE_USE_WCHAR
 using EditLineStringType = std::wstring;
 using EditLineStringStreamType = std::wstringstream;

include/lldb/Host/Predicate.h

-//===-- Predicate.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_Predicate_h_
-#define liblldb_Predicate_h_
-
-// C Includes
-#include <stdint.h>
-#include <time.h>
-
-// C++ Includes
-#include <condition_variable>
-#include <mutex>
-
-// Other libraries and framework includes
-// Project includes
-#include "lldb/Utility/Timeout.h"
-#include "lldb/lldb-defines.h"
-
-//#define DB_PTHREAD_LOG_EVENTS
-
-//----------------------------------------------------------------------
-/// Enumerations for broadcasting.
-//----------------------------------------------------------------------
-namespace lldb_private {
-
-typedef enum {
-  eBroadcastNever,   ///< No broadcast will be sent when the value is modified.
-  eBroadcastAlways,  ///< Always send a broadcast when the value is modified.
-  eBroadcastOnChange ///< Only broadcast if the value changes when the value is
-                     ///modified.
-} PredicateBroadcastType;
-
-//----------------------------------------------------------------------
-/// @class Predicate Predicate.h "lldb/Host/Predicate.h"
-/// A C++ wrapper class for providing threaded access to a value of
-/// type T.
-///
-/// A templatized class that provides multi-threaded access to a value
-/// of type T. Threads can efficiently wait for bits within T to be set
-/// or reset, or wait for T to be set to be equal/not equal to a
-/// specified values.
-//----------------------------------------------------------------------
-template <class T> class Predicate {
-public:
-  //------------------------------------------------------------------
-  /// Default constructor.
-  ///
-  /// Initializes the mutex, condition and value with their default
-  /// constructors.
-  //------------------------------------------------------------------
-  Predicate() : m_value(), m_mutex(), m_condition() {}
-
-  //------------------------------------------------------------------
-  /// Construct with initial T value \a initial_value.
-  ///
-  /// Initializes the mutex and condition with their default
-  /// constructors, and initializes the value with \a initial_value.
-  ///
-  /// @param[in] initial_value
-  ///     The initial value for our T object.
-  //------------------------------------------------------------------
-  Predicate(T initial_value)
-      : m_value(initial_value), m_mutex(), m_condition() {}
-
-  //------------------------------------------------------------------
-  /// Destructor.
-  ///
-  /// Destroy the condition, mutex, and T objects.
-  //------------------------------------------------------------------
-  ~Predicate() = default;
-
-  //------------------------------------------------------------------
-  /// Value get accessor.
-  ///
-  /// Copies the current \a m_value in a thread safe manor and returns
-  /// the copied value.
-  ///
-  /// @return
-  ///     A copy of the current value.
-  //------------------------------------------------------------------
-  T GetValue() const {
-    std::lock_guard<std::mutex> guard(m_mutex);
-    T value = m_value;
-    return value;
-  }
-
-  //------------------------------------------------------------------
-  /// Value set accessor.
-  ///
-  /// Set the contained \a m_value to \a new_value in a thread safe
-  /// way and broadcast if needed.
-  ///
-  /// @param[in] value
-  ///     The new value to set.
-  ///
-  /// @param[in] broadcast_type
-  ///     A value indicating when and if to broadcast. See the
-  ///     PredicateBroadcastType enumeration for details.
-  ///
-  /// @see Predicate::Broadcast()
-  //------------------------------------------------------------------
-  void SetValue(T value, PredicateBroadcastType broadcast_type) {
-    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
-    const T old_value = m_value;
-    m_value = value;
-
-    Broadcast(old_value, broadcast_type);
-  }
-
-  //------------------------------------------------------------------
-  /// Wait for Cond(m_value) to be true.
-  ///
-  /// Waits in a thread safe way for Cond(m_value) to be true. If Cond(m_value)
-  /// is already true, this function will return without waiting.
-  ///
-  /// It is possible for the value to be changed between the time the value is
-  /// set and the time the waiting thread wakes up. If the value no longer
-  /// satisfies the condition when the waiting thread wakes up, it will go back
-  /// into a wait state. It may be necessary for the calling code to use
-  /// additional thread synchronization methods to detect transitory states.
-  ///
-  /// @param[in] Cond
-  ///     The condition we want \a m_value satisfy.
-  ///
-  /// @param[in] timeout
-  ///     How long to wait for the condition to hold.
-  ///
-  /// @return
-  ///     @li m_value if Cond(m_value) is true.
-  ///     @li None otherwise (timeout occurred).
-  //------------------------------------------------------------------
-  template <typename C>
-  llvm::Optional<T> WaitFor(C Cond, const Timeout<std::micro> &timeout) {
-    std::unique_lock<std::mutex> lock(m_mutex);
-    auto RealCond = [&] { return Cond(m_value); };
-    if (!timeout) {
-      m_condition.wait(lock, RealCond);
-      return m_value;
-    }
-    if (m_condition.wait_for(lock, *timeout, RealCond))
-      return m_value;
-    return llvm::None;
-  }
-  //------------------------------------------------------------------
-  /// Wait for \a m_value to be equal to \a value.
-  ///
-  /// Waits in a thread safe way for \a m_value to be equal to \a
-  /// value. If \a m_value is already equal to \a value, this
-  /// function will return without waiting.
-  ///
-  /// It is possible for the value to be changed between the time
-  /// the value is set and the time the waiting thread wakes up.
-  /// If the value no longer matches the requested value when the
-  /// waiting thread wakes up, it will go back into a wait state.  It
-  /// may be necessary for the calling code to use additional thread
-  /// synchronization methods to detect transitory states.
-  ///
-  /// @param[in] value
-  ///     The value we want \a m_value to be equal to.
-  ///
-  /// @param[in] timeout
-  ///     How long to wait for the condition to hold.
-  ///
-  /// @return
-  ///     @li \b true if the \a m_value is equal to \a value
-  ///     @li \b false otherwise (timeout occurred)
-  //------------------------------------------------------------------
-  bool WaitForValueEqualTo(T value,
-                           const Timeout<std::micro> &timeout = llvm::None) {
-    return WaitFor([&value](T current) { return value == current; }, timeout) !=
-           llvm::None;
-  }
-
-  //------------------------------------------------------------------
-  /// Wait for \a m_value to not be equal to \a value.
-  ///
-  /// Waits in a thread safe way for \a m_value to not be equal to \a
-  /// value. If \a m_value is already not equal to \a value, this
-  /// function will return without waiting.
-  ///
-  /// It is possible for the value to be changed between the time
-  /// the value is set and the time the waiting thread wakes up.
-  /// If the value is equal to the test value when the waiting thread
-  /// wakes up, it will go back into a wait state.  It may be
-  /// necessary for the calling code to use additional thread
-  /// synchronization methods to detect transitory states.
-  ///
-  /// @param[in] value
-  ///     The value we want \a m_value to not be equal to.
-  ///
-  /// @param[in] timeout
-  ///     How long to wait for the condition to hold.
-  ///
-  /// @return
-  ///     @li m_value if m_value != value
-  ///     @li None otherwise (timeout occurred).
-  //------------------------------------------------------------------
-  llvm::Optional<T>
-  WaitForValueNotEqualTo(T value,
-                         const Timeout<std::micro> &timeout = llvm::None) {
-    return WaitFor([&value](T current) { return value != current; }, timeout);
-  }
-
-protected:
-  //----------------------------------------------------------------------
-  // pthread condition and mutex variable to control access and allow blocking
-  // between the main thread and the spotlight index thread.
-  //----------------------------------------------------------------------
-  T m_value; ///< The templatized value T that we are protecting access to
-  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:
-  //------------------------------------------------------------------
-  /// Broadcast if needed.
-  ///
-  /// Check to see if we need to broadcast to our condition variable
-  /// depending on the \a old_value and on the \a broadcast_type.
-  ///
-  /// If \a broadcast_type is eBroadcastNever, no broadcast will be
-  /// sent.
-  ///
-  /// If \a broadcast_type is eBroadcastAlways, the condition variable
-  /// will always be broadcast.
-  ///
-  /// If \a broadcast_type is eBroadcastOnChange, the condition
-  /// variable be broadcast if the owned value changes.
-  //------------------------------------------------------------------
-  void Broadcast(T old_value, PredicateBroadcastType broadcast_type) {
-    bool broadcast =
-        (broadcast_type == eBroadcastAlways) ||
-        ((broadcast_type == eBroadcastOnChange) && old_value != m_value);
-#ifdef DB_PTHREAD_LOG_EVENTS
-    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.notify_all();
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(Predicate);
-};
-
-} // namespace lldb_private
-
-#endif // liblldb_Predicate_h_

include/lldb/Host/Socket.h

 #ifndef liblldb_Host_Socket_h_
 #define liblldb_Host_Socket_h_
 
 #include <memory>
 #include <string>
 
 #include "lldb/lldb-private.h"
 
-#include "lldb/Host/Predicate.h"
 #include "lldb/Host/SocketAddress.h"
 #include "lldb/Utility/IOObject.h"
+#include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/Status.h"
 
 #ifdef _WIN32
 #include "lldb/Host/windows/windows.h"
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #endif
 

include/lldb/Host/posix/ConnectionFileDescriptorPosix.h

 #include <memory>
 #include <mutex>
 
 #include "lldb/lldb-forward.h"
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Host/Pipe.h"
-#include "lldb/Host/Predicate.h"
 #include "lldb/Utility/Connection.h"
 #include "lldb/Utility/IOObject.h"
+#include "lldb/Utility/Predicate.h"
 
 namespace lldb_private {
 
 class Status;
 class Socket;
 class SocketAddress;
 
 class ConnectionFileDescriptor : public Connection {

include/lldb/Utility/Predicate.h

+//===-- Predicate.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_Predicate_h_
+#define liblldb_Predicate_h_
+
+// C Includes
+#include <stdint.h>
+#include <time.h>
+
+// C++ Includes
+#include <condition_variable>
+#include <mutex>
+
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Utility/Timeout.h"
+#include "lldb/lldb-defines.h"
+
+//#define DB_PTHREAD_LOG_EVENTS
+
+//----------------------------------------------------------------------
+/// Enumerations for broadcasting.
+//----------------------------------------------------------------------
+namespace lldb_private {
+
+typedef enum {
+  eBroadcastNever,   ///< No broadcast will be sent when the value is modified.
+  eBroadcastAlways,  ///< Always send a broadcast when the value is modified.
+  eBroadcastOnChange ///< Only broadcast if the value changes when the value is
+                     /// modified.
+} PredicateBroadcastType;
+
+//----------------------------------------------------------------------
+/// @class Predicate Predicate.h "lldb/Utility/Predicate.h"
+/// A C++ wrapper class for providing threaded access to a value of
+/// type T.
+///
+/// A templatized class that provides multi-threaded access to a value
+/// of type T. Threads can efficiently wait for bits within T to be set
+/// or reset, or wait for T to be set to be equal/not equal to a
+/// specified values.
+//----------------------------------------------------------------------
+template <class T> class Predicate {
+public:
+  //------------------------------------------------------------------
+  /// Default constructor.
+  ///
+  /// Initializes the mutex, condition and value with their default
+  /// constructors.
+  //------------------------------------------------------------------
+  Predicate() : m_value(), m_mutex(), m_condition() {}
+
+  //------------------------------------------------------------------
+  /// Construct with initial T value \a initial_value.
+  ///
+  /// Initializes the mutex and condition with their default
+  /// constructors, and initializes the value with \a initial_value.
+  ///
+  /// @param[in] initial_value
+  ///     The initial value for our T object.
+  //------------------------------------------------------------------
+  Predicate(T initial_value)
+      : m_value(initial_value), m_mutex(), m_condition() {}
+
+  //------------------------------------------------------------------
+  /// Destructor.
+  ///
+  /// Destroy the condition, mutex, and T objects.
+  //------------------------------------------------------------------
+  ~Predicate() = default;
+
+  //------------------------------------------------------------------
+  /// Value get accessor.
+  ///
+  /// Copies the current \a m_value in a thread safe manor and returns
+  /// the copied value.
+  ///
+  /// @return
+  ///     A copy of the current value.
+  //------------------------------------------------------------------
+  T GetValue() const {
+    std::lock_guard<std::mutex> guard(m_mutex);
+    T value = m_value;
+    return value;
+  }
+
+  //------------------------------------------------------------------
+  /// Value set accessor.
+  ///
+  /// Set the contained \a m_value to \a new_value in a thread safe
+  /// way and broadcast if needed.
+  ///
+  /// @param[in] value
+  ///     The new value to set.
+  ///
+  /// @param[in] broadcast_type
+  ///     A value indicating when and if to broadcast. See the
+  ///     PredicateBroadcastType enumeration for details.
+  ///
+  /// @see Predicate::Broadcast()
+  //------------------------------------------------------------------
+  void SetValue(T value, PredicateBroadcastType broadcast_type) {
+    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
+    const T old_value = m_value;
+    m_value = value;
+
+    Broadcast(old_value, broadcast_type);
+  }
+
+  //------------------------------------------------------------------
+  /// Wait for Cond(m_value) to be true.
+  ///
+  /// Waits in a thread safe way for Cond(m_value) to be true. If Cond(m_value)
+  /// is already true, this function will return without waiting.
+  ///
+  /// It is possible for the value to be changed between the time the value is
+  /// set and the time the waiting thread wakes up. If the value no longer
+  /// satisfies the condition when the waiting thread wakes up, it will go back
+  /// into a wait state. It may be necessary for the calling code to use
+  /// additional thread synchronization methods to detect transitory states.
+  ///
+  /// @param[in] Cond
+  ///     The condition we want \a m_value satisfy.
+  ///
+  /// @param[in] timeout
+  ///     How long to wait for the condition to hold.
+  ///
+  /// @return
+  ///     @li m_value if Cond(m_value) is true.
+  ///     @li None otherwise (timeout occurred).
+  //------------------------------------------------------------------
+  template <typename C>
+  llvm::Optional<T> WaitFor(C Cond, const Timeout<std::micro> &timeout) {
+    std::unique_lock<std::mutex> lock(m_mutex);
+    auto RealCond = [&] { return Cond(m_value); };
+    if (!timeout) {
+      m_condition.wait(lock, RealCond);
+      return m_value;
+    }
+    if (m_condition.wait_for(lock, *timeout, RealCond))
+      return m_value;
+    return llvm::None;
+  }
+  //------------------------------------------------------------------
+  /// Wait for \a m_value to be equal to \a value.
+  ///
+  /// Waits in a thread safe way for \a m_value to be equal to \a
+  /// value. If \a m_value is already equal to \a value, this
+  /// function will return without waiting.
+  ///
+  /// It is possible for the value to be changed between the time
+  /// the value is set and the time the waiting thread wakes up.
+  /// If the value no longer matches the requested value when the
+  /// waiting thread wakes up, it will go back into a wait state.  It
+  /// may be necessary for the calling code to use additional thread
+  /// synchronization methods to detect transitory states.
+  ///
+  /// @param[in] value
+  ///     The value we want \a m_value to be equal to.
+  ///
+  /// @param[in] timeout
+  ///     How long to wait for the condition to hold.
+  ///
+  /// @return
+  ///     @li \b true if the \a m_value is equal to \a value
+  ///     @li \b false otherwise (timeout occurred)
+  //------------------------------------------------------------------
+  bool WaitForValueEqualTo(T value,
+                           const Timeout<std::micro> &timeout = llvm::None) {
+    return WaitFor([&value](T current) { return value == current; }, timeout) !=
+           llvm::None;
+  }
+
+  //------------------------------------------------------------------
+  /// Wait for \a m_value to not be equal to \a value.
+  ///
+  /// Waits in a thread safe way for \a m_value to not be equal to \a
+  /// value. If \a m_value is already not equal to \a value, this
+  /// function will return without waiting.
+  ///
+  /// It is possible for the value to be changed between the time
+  /// the value is set and the time the waiting thread wakes up.
+  /// If the value is equal to the test value when the waiting thread
+  /// wakes up, it will go back into a wait state.  It may be
+  /// necessary for the calling code to use additional thread
+  /// synchronization methods to detect transitory states.
+  ///
+  /// @param[in] value
+  ///     The value we want \a m_value to not be equal to.
+  ///
+  /// @param[in] timeout
+  ///     How long to wait for the condition to hold.
+  ///
+  /// @return
+  ///     @li m_value if m_value != value
+  ///     @li None otherwise (timeout occurred).
+  //------------------------------------------------------------------
+  llvm::Optional<T>
+  WaitForValueNotEqualTo(T value,
+                         const Timeout<std::micro> &timeout = llvm::None) {
+    return WaitFor([&value](T current) { return value != current; }, timeout);
+  }
+
+protected:
+  //----------------------------------------------------------------------
+  // pthread condition and mutex variable to control access and allow blocking
+  // between the main thread and the spotlight index thread.
+  //----------------------------------------------------------------------
+  T m_value; ///< The templatized value T that we are protecting access to
+  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:
+  //------------------------------------------------------------------
+  /// Broadcast if needed.
+  ///
+  /// Check to see if we need to broadcast to our condition variable
+  /// depending on the \a old_value and on the \a broadcast_type.
+  ///
+  /// If \a broadcast_type is eBroadcastNever, no broadcast will be
+  /// sent.
+  ///
+  /// If \a broadcast_type is eBroadcastAlways, the condition variable
+  /// will always be broadcast.
+  ///
+  /// If \a broadcast_type is eBroadcastOnChange, the condition
+  /// variable be broadcast if the owned value changes.
+  //------------------------------------------------------------------
+  void Broadcast(T old_value, PredicateBroadcastType broadcast_type) {
+    bool broadcast =
+        (broadcast_type == eBroadcastAlways) ||
+        ((broadcast_type == eBroadcastOnChange) && old_value != m_value);
+#ifdef DB_PTHREAD_LOG_EVENTS
+    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.notify_all();
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(Predicate);
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_Predicate_h_

include/lldb/module.modulemap

module lldb_Host {
   module LockFile { header "Host/LockFile.h" export * }
   module MainLoopBase { header "Host/MainLoopBase.h" export * }
   module MainLoop { header "Host/MainLoop.h" export * }
   module MonitoringProcessLauncher { header "Host/MonitoringProcessLauncher.h" export * }
   module OptionParser { header "Host/OptionParser.h" export * }
   module PipeBase { header "Host/PipeBase.h" export * }
   module Pipe { header "Host/Pipe.h" export * }
   module PosixApi { header "Host/PosixApi.h" export * }
-  module Predicate { header "Host/Predicate.h" export * }
   module ProcessLauncher { header "Host/ProcessLauncher.h" export * }
   module ProcessRunLock { header "Host/ProcessRunLock.h" export * }
   module PseudoTerminal { header "Host/PseudoTerminal.h" export * }
   module SocketAddress { header "Host/SocketAddress.h" export * }
   module Socket { header "Host/Socket.h" export * }
   module StringConvert { header "Host/StringConvert.h" export * }
   module Symbols { header "Host/Symbols.h" export * }
   module TaskPool { header "Host/TaskPool.h" export * }

source/Core/IOHandler.cpp

 #endif
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/File.h"            // for File
-#include "lldb/Host/Predicate.h"       // for Predicate, ::eBroad...
+#include "lldb/Utility/Predicate.h"    // for Predicate, ::eBroad...
 #include "lldb/Utility/Status.h"       // for Status
 #include "lldb/Utility/StreamString.h" // for StreamString
 #include "lldb/Utility/StringList.h"   // for StringList
 #include "lldb/lldb-forward.h"         // for StreamFileSP
 
 #ifndef LLDB_DISABLE_LIBEDIT
 #include "lldb/Host/Editline.h"
 #endif

source/Host/common/Host.cpp

 
 // C++ Includes
 #include <csignal>
 
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/MonitoringProcessLauncher.h"
-#include "lldb/Host/Predicate.h"
 #include "lldb/Host/ProcessLauncher.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-forward.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 
 #if defined(_WIN32)

source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.h

 #include <mutex>
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Listener.h"
 #include "lldb/Core/StreamBuffer.h"
-#include "lldb/Host/Predicate.h"
+#include "lldb/Utility/Predicate.h"
 #include "lldb/lldb-private.h"
 
 class CommunicationKDP : public lldb_private::Communication {
 public:
   enum { eBroadcastBitRunPacketSent = kLoUserBroadcastBit };
 
   const static uint32_t kMaxPacketSize = 1200;
   const static uint32_t kMaxDataSize = 1024;

source/Plugins/Process/Windows/Common/DebuggerThread.h

 #define liblldb_Plugins_Process_Windows_DebuggerThread_H_
 
 #include <atomic>
 #include <memory>
 
 #include "ForwardDecl.h"
 #include "lldb/Host/HostProcess.h"
 #include "lldb/Host/HostThread.h"
-#include "lldb/Host/Predicate.h"
 #include "lldb/Host/windows/windows.h"
+#include "lldb/Utility/Predicate.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // DebuggerThread
 //
 // Debugs a single process, notifying listeners as appropriate when interesting
 // things occur.

source/Plugins/Process/Windows/Common/DebuggerThread.cpp

 //===-- DebuggerThread.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DebuggerThread.h"
 #include "ExceptionRecord.h"
 #include "IDebugDelegate.h"
 
 #include "lldb/Core/ModuleSpec.h"
-#include "lldb/Host/Predicate.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/windows/HostProcessWindows.h"
 #include "lldb/Host/windows/HostThreadWindows.h"
 #include "lldb/Host/windows/ProcessLauncherWindows.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
+#include "lldb/Utility/Predicate.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Listener.h"
 #include "lldb/Host/HostThread.h"
-#include "lldb/Host/Predicate.h"
 #include "lldb/Utility/Args.h"
+#include "lldb/Utility/Predicate.h"
 #include "lldb/lldb-public.h"
 
 #include "lldb/Utility/StringExtractorGDBRemote.h"
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
 typedef enum {

unittests/Core/BroadcasterTest.cpp

 //===-- BroadcasterTest.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/Listener.h"
-#include "lldb/Host/Predicate.h"
+#include "lldb/Utility/Predicate.h"
 
 #include <thread>
 
 using namespace lldb;
 using namespace lldb_private;
 
 TEST(BroadcasterTest, BroadcastEvent) {
   EventSP event_sp;

unittests/Host/CMakeLists.txt

 set (FILES
   FileSystemTest.cpp
   HostInfoTest.cpp
   HostTest.cpp
   MainLoopTest.cpp
-  PredicateTest.cpp
   SocketAddressTest.cpp
   SocketTest.cpp
   SymbolsTest.cpp
   TaskPoolTest.cpp
 )
 
 if (CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
   list(APPEND FILES

unittests/Host/PredicateTest.cpp

-//===-- PredicateTest.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/Predicate.h"
-#include "gtest/gtest.h"
-#include <thread>
-
-using namespace lldb_private;
-
-TEST(Predicate, WaitForValueEqualTo) {
-  Predicate<int> P(0);
-  EXPECT_TRUE(P.WaitForValueEqualTo(0));
-  EXPECT_FALSE(P.WaitForValueEqualTo(1, std::chrono::milliseconds(10)));
-
-  std::thread Setter([&P] {
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    P.SetValue(1, eBroadcastAlways);
-  });
-  EXPECT_TRUE(P.WaitForValueEqualTo(1));
-  Setter.join();
-}
-
-TEST(Predicate, WaitForValueNotEqualTo) {
-  Predicate<int> P(0);
-  EXPECT_EQ(0, P.WaitForValueNotEqualTo(1));
-  EXPECT_EQ(llvm::None,
-            P.WaitForValueNotEqualTo(0, std::chrono::milliseconds(10)));
-}

unittests/Utility/CMakeLists.txt

 add_lldb_unittest(UtilityTests
   AnsiTerminalTest.cpp
   ArgsTest.cpp
   OptionsWithRawTest.cpp
   ArchSpecTest.cpp
   CleanUpTest.cpp
   ConstStringTest.cpp
   CompletionRequestTest.cpp
   EnvironmentTest.cpp
   FileSpecTest.cpp
   FlagsTest.cpp
   JSONTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
+  PredicateTest.cpp
   RegisterValueTest.cpp
   ScalarTest.cpp
   StateTest.cpp
   StatusTest.cpp
   StreamTeeTest.cpp
   StreamTest.cpp
   StringExtractorTest.cpp
   StringLexerTest.cpp

unittests/Utility/PredicateTest.cpp

+//===-- PredicateTest.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/Utility/Predicate.h"
+#include "gtest/gtest.h"
+#include <thread>
+
+using namespace lldb_private;
+
+TEST(Predicate, WaitForValueEqualTo) {
+  Predicate<int> P(0);
+  EXPECT_TRUE(P.WaitForValueEqualTo(0));
+  EXPECT_FALSE(P.WaitForValueEqualTo(1, std::chrono::milliseconds(10)));
+
+  std::thread Setter([&P] {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    P.SetValue(1, eBroadcastAlways);
+  });
+  EXPECT_TRUE(P.WaitForValueEqualTo(1));
+  Setter.join();
+}
+
+TEST(Predicate, WaitForValueNotEqualTo) {
+  Predicate<int> P(0);
+  EXPECT_EQ(0, P.WaitForValueNotEqualTo(1));
+  EXPECT_EQ(llvm::None,
+            P.WaitForValueNotEqualTo(0, std::chrono::milliseconds(10)));
+}