Event2 code moved to module core.sync.event and renamed to EventAwaiter

Author: denizzzka

druntime/src/core/internal/gc/impl/conservative/gc.d

@@ -3281,7 +3281,7 @@ Lmark:
 
     import core.atomic;
     import core.cpuid;
-    import core.sync.event2 : Event2;
+    import core.sync.event : EventAwaiter;
 
     private: // disable invariants for background threads
 
@@ -3294,8 +3294,8 @@ Lmark:
 
     static struct EvStartDone
     {
-        Event2 start;
-        Event2 done;
+        EventAwaiter start;
+        EventAwaiter done;
     }
     EvStartDone ev;
 
@@ -3399,8 +3399,8 @@ Lmark:
         if (!scanThreadData)
             onOutOfMemoryError();
 
-        ev.start = Event2(false, false);
-        ev.done = Event2(false, false);
+        ev.start = EventAwaiter(false, false);
+        ev.done = EventAwaiter(false, false);
 
         version (Posix)
         {

druntime/src/core/sync/event.d

@@ -13,7 +13,122 @@ module core.sync.event;
 
 import core.time;
 
-import core.sync.event2;
+struct EventAwaiter
+{
+nothrow @nogc:
+    /**
+     * Creates an event object.
+     *
+     * Params:
+     *  manualReset  = the state of the event is not reset automatically after resuming waiting clients
+     *  initialState = initial state of the signal
+     */
+    this(bool manualReset, bool initialState)
+    {
+        osEvent = OsEvent(manualReset, initialState);
+    }
+
+    // copying not allowed, can produce resource leaks
+    @disable this(this);
+
+    ref EventAwaiter opAssign(return scope EventAwaiter s) @live
+    {
+        this.osEvent = s.osEvent;
+
+        return this;
+    }
+
+    /// Set the event to "signaled", so that waiting clients are resumed
+    void set()
+    {
+        osEvent.set();
+    }
+
+    /// Reset the event manually
+    void reset()
+    {
+        osEvent.reset();
+    }
+
+    /**
+     * Wait for the event to be signaled without timeout.
+     *
+     * Returns:
+     *  `true` if the event is in signaled state, `false` if the event is uninitialized or another error occured
+     */
+    bool wait()
+    {
+        return osEvent.wait();
+    }
+
+    /**
+     * Wait for the event to be signaled with timeout.
+     *
+     * Params:
+     *  tmout = the maximum time to wait
+     * Returns:
+     *  `true` if the event is in signaled state, `false` if the event was nonsignaled for the given time or
+     *  the event is uninitialized or another error occured
+     */
+    bool wait(Duration tmout)
+    {
+        return osEvent.wait(tmout);
+    }
+
+private:
+    import rt.sys.config;
+
+    mixin("import " ~ osEventImport ~ ";");
+    OsEvent osEvent;
+}
+
+// Test single-thread (non-shared) use.
+@nogc nothrow unittest
+{
+    // auto-reset, initial state false
+    EventAwaiter ev1 = EventAwaiter(false, false);
+    assert(!ev1.wait(1.dur!"msecs"));
+    ev1.set();
+    assert(ev1.wait());
+    assert(!ev1.wait(1.dur!"msecs"));
+
+    // manual-reset, initial state true
+    EventAwaiter ev2 = EventAwaiter(true, true);
+    assert(ev2.wait());
+    assert(ev2.wait());
+    ev2.reset();
+    assert(!ev2.wait(1.dur!"msecs"));
+}
+
+unittest
+{
+    import core.thread, core.atomic;
+
+    scope event      = new EventAwaiter(true, false);
+    int  numThreads = 10;
+    shared int numRunning = 0;
+
+    void testFn()
+    {
+        event.wait(8.dur!"seconds"); // timeout below limit for druntime test_runner
+        numRunning.atomicOp!"+="(1);
+    }
+
+    auto group = new ThreadGroup;
+
+    for (int i = 0; i < numThreads; ++i)
+        group.create(&testFn);
+
+    auto start = MonoTime.currTime;
+    assert(numRunning == 0);
+
+    event.set();
+    group.joinAll();
+
+    assert(numRunning == numThreads);
+
+    assert(MonoTime.currTime - start < 5.dur!"seconds");
+}
 
 /**
  * represents an event. Clients of an event are suspended while waiting
@@ -51,7 +166,7 @@ struct ProcessFile
 }
 ---
  */
-deprecated("Please use core.sync.event2.Event2 instead")
+deprecated("Please use core.sync.event.EventAwaiter instead")
 struct Event
 {
 nothrow @nogc:
@@ -76,7 +191,7 @@ nothrow @nogc:
      */
     void initialize(bool manualReset, bool initialState) @live
     {
-        osEvent = Event2(manualReset, initialState);
+        osEvent = EventAwaiter(manualReset, initialState);
         m_initalized = true;
     }
 
@@ -150,7 +265,7 @@ nothrow @nogc:
     }
 
 private:
-    Event2 osEvent;
+    EventAwaiter osEvent;
     bool m_initalized;
 }