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/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

 /// 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.
+                     /// modified.
 } PredicateBroadcastType;
 
 //----------------------------------------------------------------------
-/// @class Predicate Predicate.h "lldb/Host/Predicate.h"
+/// @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.
 //----------------------------------------------------------------------

 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.
+                                       /// 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.
   ///

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/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
   StringListTest.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/Host/Predicate.h"
+#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));