Merge pull request #3085 from briancroom/sourcekit-semaphore

[SourceKit] Add Semaphore to SourceKitSupport's concurrency module

Author: briancroom

tools/SourceKit/include/SourceKit/Support/Concurrency.h

@@ -17,6 +17,55 @@
 
 namespace SourceKit {
 
+class Semaphore {
+public:
+  Semaphore(long count) {
+    ImplObj = Impl::create(count);
+  }
+  ~Semaphore() {
+    if (ImplObj)
+      Impl::release(ImplObj);
+  }
+
+  void signal() {
+    Impl::signal(ImplObj);
+  }
+
+  bool wait() {
+    return Impl::wait(ImplObj);
+  }
+
+  bool wait(long milliseconds) {
+    return Impl::wait(ImplObj, milliseconds);
+  }
+
+  Semaphore(const Semaphore &Other) = delete;
+  Semaphore(Semaphore &&Other) {
+    ImplObj = std::move(Other.ImplObj);
+    Other.ImplObj = Impl::Ty();
+  }
+
+  Semaphore &operator=(const Semaphore &Other) = delete;
+  Semaphore &operator=(Semaphore &&Other) {
+    Semaphore Tmp(std::move(Other));
+    std::swap(ImplObj, Tmp.ImplObj);
+    return *this;
+  }
+private:
+  // Platform-specific implementation.
+  struct Impl {
+    typedef void *Ty;
+    static Ty create(long count);
+    static void signal(Ty Obj);
+    static bool wait(Ty Obj);
+    static bool wait(Ty Obj, long milliseconds);
+    static void retain(Ty Obj);
+    static void release(Ty Obj);
+  };
+
+  Impl::Ty ImplObj;
+};
+
 class WorkQueue {
 public:
   enum class Dequeuing {

tools/SourceKit/lib/Support/Concurrency-Mac.cpp

@@ -21,6 +21,34 @@
 
 using namespace SourceKit;
 
+void *Semaphore::Impl::create(long count) {
+  return dispatch_semaphore_create(count);
+}
+
+void Semaphore::Impl::signal(Ty Obj) {
+  dispatch_semaphore_signal(dispatch_semaphore_t(Obj));
+}
+
+bool Semaphore::Impl::wait(Ty Obj) {
+  return dispatch_semaphore_wait(dispatch_semaphore_t(Obj), 
+                                 DISPATCH_TIME_FOREVER);
+}
+
+bool Semaphore::Impl::wait(Ty Obj, long milliseconds) {
+  dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 
+                                          milliseconds * NSEC_PER_MSEC);
+  return dispatch_semaphore_wait(dispatch_semaphore_t(Obj), timeout);
+}
+
+void Semaphore::Impl::retain(Ty Obj) {
+  dispatch_retain(dispatch_semaphore_t(Obj));
+}
+
+void Semaphore::Impl::release(Ty Obj) {
+  dispatch_release(dispatch_semaphore_t(Obj));
+}
+
+
 static dispatch_queue_priority_t toDispatchPriority(WorkQueue::Priority Prio) {
   switch (Prio) {
   case WorkQueue::Priority::High: return DISPATCH_QUEUE_PRIORITY_HIGH;

tools/SourceKit/tools/sourcekitd-test/CMakeLists.txt

@@ -11,7 +11,7 @@ endif()
 add_sourcekit_executable(sourcekitd-test
   sourcekitd-test.cpp
   TestOptions.cpp
-  DEPENDS ${SOURCEKITD_TEST_DEPEND}
+  DEPENDS ${SOURCEKITD_TEST_DEPEND} SourceKitSupport
     clangRewrite clangLex clangBasic
   COMPONENT_DEPENDS support option
 )

tools/SourceKit/tools/sourcekitd-test/sourcekitd-test.cpp

@@ -13,6 +13,7 @@
 #include "sourcekitd/sourcekitd.h"
 
 #include "TestOptions.h"
+#include "SourceKit/Support/Concurrency.h"
 #include "clang/Rewrite/Core/RewriteBuffer.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
@@ -149,7 +150,7 @@ static sourcekitd_uid_t SemaDiagnosticStage;
 
 static sourcekitd_uid_t NoteDocUpdate;
 
-static dispatch_semaphore_t semaSemaphore;
+static SourceKit::Semaphore semaSemaphore(0);
 static sourcekitd_response_t semaResponse;
 static const char *semaName;
 
@@ -222,8 +223,6 @@ static int skt_main(int argc, const char **argv) {
 
   NoteDocUpdate = sourcekitd_uid_get_from_cstr("source.notification.editor.documentupdate");
 
-  semaSemaphore = dispatch_semaphore_create(0);
-
   RequestProtocolVersion = sourcekitd_uid_get_from_cstr("source.request.protocol_version");
   RequestDemangle = sourcekitd_uid_get_from_cstr("source.request.demangle");
   RequestMangleSimpleClass = sourcekitd_uid_get_from_cstr("source.request.mangle_simple_class");
@@ -864,8 +863,7 @@ static void getSemanticInfo(sourcekitd_variant_t Info, StringRef Filename) {
 
   // Wait for the notification that semantic info is available.
   // But only for 1 min.
-  dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 60);
-  bool expired = dispatch_semaphore_wait(semaSemaphore, when);
+  bool expired = semaSemaphore.wait(60 * 1000);
   if (expired) {
     llvm::report_fatal_error("Never got notification for semantic info");
   }
@@ -914,7 +912,7 @@ static void notification_receiver(sourcekitd_response_t resp) {
     sourcekitd_request_dictionary_set_string(edReq, KeySourceText, "");
     semaResponse = sourcekitd_send_request_sync(edReq);
     sourcekitd_request_release(edReq);
-    dispatch_semaphore_signal(semaSemaphore);
+    semaSemaphore.signal();
   }
 }
 

tools/SourceKit/tools/sourcekitd/bin/InProc/sourcekitdInProc.cpp

@@ -20,7 +20,6 @@
 
 // FIXME: Portability ?
 #include <Block.h>
-#include <dispatch/dispatch.h>
 
 #ifdef LLVM_ON_WIN32
 #define WIN32_LEAN_AND_MEAN
@@ -104,16 +103,15 @@ void sourcekitd::set_interrupted_connection_handler(
 //===----------------------------------------------------------------------===//
 
 sourcekitd_response_t sourcekitd_send_request_sync(sourcekitd_object_t req) {
-  dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+  Semaphore sema(0);
 
   sourcekitd_response_t ReturnedResp;
   sourcekitd::handleRequest(req, [&](sourcekitd_response_t resp) {
     ReturnedResp = resp;
-    dispatch_semaphore_signal(sema);
+    sema.signal();
   });
 
-  dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
-  dispatch_release(sema);
+  sema.wait();
   return ReturnedResp;
 }
 

unittests/SourceKit/SwiftLang/CursorInfoTest.cpp

@@ -13,13 +13,11 @@
 #include "SourceKit/Core/Context.h"
 #include "SourceKit/Core/LangSupport.h"
 #include "SourceKit/Core/NotificationCenter.h"
+#include "SourceKit/Support/Concurrency.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "gtest/gtest.h"
 
-// FIXME: Portability.
-#include <dispatch/dispatch.h>
-
 using namespace SourceKit;
 using namespace llvm;
 
@@ -98,18 +96,12 @@ struct TestCursorInfo {
 class CursorInfoTest : public ::testing::Test {
   SourceKit::Context Ctx{ getRuntimeLibPath() };
   std::atomic<int> NumTasks;
-  dispatch_semaphore_t TaskSema = nullptr;
 
 public:
   LangSupport &getLang() { return Ctx.getSwiftLangSupport(); }
 
   void SetUp() {
     NumTasks = 0;
-    TaskSema = dispatch_semaphore_create(0);
-  }
-
-  void TearDown() {
-    dispatch_release(TaskSema);
   }
 
   void addNotificationReceiver(DocumentUpdateNotificationReceiver Receiver) {
@@ -133,7 +125,7 @@ class CursorInfoTest : public ::testing::Test {
   TestCursorInfo getCursor(const char *DocName, unsigned Offset,
                            ArrayRef<const char *> CArgs) {
     auto Args = makeArgs(DocName, CArgs);
-    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+    Semaphore sema(0);
 
     TestCursorInfo TestInfo;
     getLang().getCursorInfo(DocName, Offset, Args,
@@ -142,40 +134,15 @@ class CursorInfoTest : public ::testing::Test {
         TestInfo.Typename = Info.TypeName;
         TestInfo.Filename = Info.Filename;
         TestInfo.DeclarationLoc = Info.DeclarationLoc;
-        dispatch_semaphore_signal(sema);
+        sema.signal();
       });
 
-    dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 60);
-    bool expired = dispatch_semaphore_wait(sema, when);
+    bool expired = sema.wait(60 * 1000);
     if (expired)
       llvm::report_fatal_error("check took too long");
-    dispatch_release(sema);
     return TestInfo;
   }
 
-  void checkCursorAsync(const char *DocName, unsigned Offset,
-                        ArrayRef<const char *> CArgs,
-                        StringRef ExpectedName, StringRef ExpectedTypename) {
-    auto Args = makeArgs(DocName, CArgs);
-    ++NumTasks;
-    getLang().getCursorInfo(DocName, Offset, Args,
-      [this, ExpectedName, ExpectedTypename](const CursorInfo &Info) {
-        EXPECT_EQ(ExpectedName, Info.Name);
-        EXPECT_EQ(ExpectedTypename, Info.TypeName);
-
-        int Num = --NumTasks;
-        if (Num == 0)
-          dispatch_semaphore_signal(TaskSema);
-      });
-  }
-
-  void waitForChecks() {
-    dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 60);
-    bool expired = dispatch_semaphore_wait(TaskSema, when);
-    if (expired)
-      llvm::report_fatal_error("checks took too long");
-  }
-
   unsigned findOffset(StringRef Val, StringRef Text) {
     auto pos = Text.find(Val);
     assert(pos != StringRef::npos);