From e8ba981263e5b0d7ebfea97bb7b1b00ea532d695 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=B6nke=20Ludwig?= Date: Wed, 15 Jun 2016 18:21:33 +0200 Subject: [PATCH] Draft proper shared semantics for ManualEvent. --- source/vibe/core/sync.d | 143 ++++++++++++++++++++++++++-------------- 1 file changed, 93 insertions(+), 50 deletions(-) diff --git a/source/vibe/core/sync.d b/source/vibe/core/sync.d index df3a878..cd6a82a 100644 --- a/source/vibe/core/sync.d +++ b/source/vibe/core/sync.d @@ -126,13 +126,13 @@ class LocalTaskSemaphore //import vibe.utils.memory; private { - static struct Waiter { + static struct ThreadWaiter { ManualEvent signal; ubyte priority; uint seq; } - BinaryHeap!(Array!Waiter, asc) m_waiters; + BinaryHeap!(Array!ThreadWaiter, asc) m_waiters; uint m_maxLocks; uint m_locks; uint m_seq; @@ -182,7 +182,7 @@ class LocalTaskSemaphore if (tryLock()) return; - Waiter w; + ThreadWaiter w; w.signal = createManualEvent(); w.priority = priority; w.seq = min(0, m_seq - w.priority); @@ -201,7 +201,7 @@ class LocalTaskSemaphore { m_locks--; if (m_waiters.length > 0 && available > 0) { - Waiter w = m_waiters.front(); + ThreadWaiter w = m_waiters.front(); w.signal.emit(); // resume one m_waiters.removeFront(); } @@ -209,7 +209,7 @@ class LocalTaskSemaphore // if true, a goes after b. ie. b comes out front() /// private - static bool asc(ref Waiter a, ref Waiter b) + static bool asc(ref ThreadWaiter a, ref ThreadWaiter b) { if (a.seq == b.seq) { if (a.priority == b.priority) { @@ -225,7 +225,7 @@ class LocalTaskSemaphore private void rewindSeq() { - Array!Waiter waiters = m_waiters.release(); + Array!ThreadWaiter waiters = m_waiters.release(); ushort min_seq; import std.algorithm : min; foreach (ref waiter; waiters[]) @@ -644,23 +644,24 @@ shared(ManualEvent) createSharedManualEvent() */ struct ManualEvent { import core.thread : Thread; - import vibe.internal.async : asyncAwait, asyncAwaitUninterruptible; + import vibe.internal.async : Waitable, asyncAwait, asyncAwaitUninterruptible, asyncAwaitAny; private { - static struct Waiter { - Waiter* next; - immutable EventID event; - immutable EventDriver driver; - immutable Thread thread; - StackSList!ThreadWaiter tasks; - } static struct ThreadWaiter { ThreadWaiter* next; + /*immutable*/ EventID event; + /*immutable*/ EventDriver driver; + //immutable Thread thread; + StackSList!LocalWaiter tasks; + } + static struct LocalWaiter { + LocalWaiter* next; Task task; void delegate() @safe nothrow notifier; + bool cancelled = false; void wait(void delegate() @safe nothrow del) @safe nothrow { assert(notifier is null); notifier = del; } - void cancel() @safe nothrow { notifier = null; } + void cancel() @safe nothrow { cancelled = true; auto n = notifier; notifier = null; n(); } void wait(void delegate() @safe nothrow del) shared @safe nothrow { @@ -675,7 +676,7 @@ struct ManualEvent { } } int m_emitCount; - Waiter* m_waiters; + ThreadWaiter* m_waiters; } @@ -710,20 +711,22 @@ struct ManualEvent { final switch (mode) { case EmitMode.all: // FIXME: would be nice to have atomicSwap instead - auto w = cast(Waiter*)atomicLoad(m_waiters); - if (w !is null && !cas(&m_waiters, cast(shared(Waiter)*)w, cast(shared(Waiter)*)null)) + auto w = cast(ThreadWaiter*)atomicLoad(m_waiters); + if (w !is null && !cas(&m_waiters, cast(shared(ThreadWaiter)*)w, cast(shared(ThreadWaiter)*)null)) return ec; while (w !is null) { - if (w.thread is thisthr) { + if (w.driver is eventDriver) { // Note: emitForThisThread can result in w getting deallocated at any // time, so we need to copy any fields first auto tasks = w.tasks; w = w.next; emitForThisThread(w.tasks.m_first, mode); } else { + auto drv = w.driver; auto evt = w.event; w = w.next; - eventDriver.triggerEvent(evt, true); + if (evt != EventID.init) + drv.triggerEvent(evt, true); } } break; @@ -742,7 +745,7 @@ struct ManualEvent { auto w = m_waiters; m_waiters = null; if (w !is null) { - assert(w.thread is Thread.getThis(), "Unshared ManualEvent has waiters in foreign thread!"); + assert(w.driver is eventDriver, "Unshared ManualEvent has waiters in foreign thread!"); assert(w.next is null, "Unshared ManualEvent has waiters in multiple threads!"); emitForThisThread(w.tasks.m_first, EmitMode.all); } @@ -781,8 +784,8 @@ struct ManualEvent { */ int wait(Duration timeout, int emit_count) { - Waiter w; - ThreadWaiter tw; + ThreadWaiter w; + LocalWaiter tw; int ec = this.emitCount; while (ec <= emit_count) { @@ -799,12 +802,13 @@ struct ManualEvent { /// ditto int wait(Duration timeout, int emit_count) shared { - shared(Waiter) w; - ThreadWaiter tw; - acquireWaiter(w, tw); + shared(ThreadWaiter) w; + LocalWaiter tw; int ec = this.emitCount; while (ec <= emit_count) { + acquireWaiter(w, tw); + if (tw.next) { // if we are not the first waiter for this thread, // wait for getting resumed by emitForThisThread @@ -816,14 +820,21 @@ struct ManualEvent { } else { // if we are the first waiter for this thread, // wait for the thread event to get emitted - /*asyncAwait!(EventCallback, void delegate() @safe nothrow, + Waitable!( cb => eventDriver.waitForEvent(ms_threadEvent, cb), + cb => eventDriver.cancelWaitForEvent(ms_threadEvent, cb), + EventID + ) eventwaiter; + Waitable!( cb => tw.wait(cb), - cb => eventDriver.cancelWaitForEvent(ms_threadEvent) - )(timeout); - emitForThisThread(w.waiters); - ec = this.emitCount;*/ - assert(false); + cb => tw.cancel() + ) localwaiter; + asyncAwaitAny!true(timeout, eventwaiter, localwaiter); + + ec = this.emitCount; + + if (!eventwaiter.cancelled) emitForThisThread(cast(LocalWaiter*)w.tasks.m_first, EmitMode.all); // FIXME: use proper emit mode + else if (localwaiter.cancelled) break; // timeout } } return ec; @@ -844,8 +855,8 @@ struct ManualEvent { /// ditto int waitUninterruptible(Duration timeout, int emit_count) nothrow { - Waiter w; - ThreadWaiter tw; + ThreadWaiter w; + LocalWaiter tw; acquireWaiter(w, tw); int ec = this.emitCount; @@ -861,23 +872,45 @@ struct ManualEvent { /// ditto int waitUninterruptible(Duration timeout, int emit_count) shared nothrow { - /*Waiter w; - ThreadWaiter tw; - auto event = acquireWaiter(w, tw); + shared(ThreadWaiter) w; + LocalWaiter tw; int ec = this.emitCount; while (ec <= emit_count) { - asyncAwaitUninterruptible!(void delegate(), - cb => tw.wait(cb), - cb => tw.cancel() - )(timeout); - ec = this.emitCount; + acquireWaiter(w, tw); + + if (tw.next) { + // if we are not the first waiter for this thread, + // wait for getting resumed by emitForThisThread + asyncAwaitUninterruptible!(void delegate() @safe nothrow, + cb => tw.wait(cb), + cb => tw.cancel() + )(timeout); + ec = this.emitCount; + } else { + // if we are the first waiter for this thread, + // wait for the thread event to get emitted + Waitable!( + cb => eventDriver.waitForEvent(ms_threadEvent, cb), + cb => eventDriver.cancelWaitForEvent(ms_threadEvent, cb), + EventID + ) eventwaiter; + Waitable!( + cb => tw.wait(cb), + cb => tw.cancel() + ) localwaiter; + asyncAwaitAny!false(timeout, eventwaiter, localwaiter); + + ec = this.emitCount; + + if (!eventwaiter.cancelled) emitForThisThread(cast(LocalWaiter*)w.tasks.m_first, EmitMode.all); // FIXME: use proper emit mode + else if (localwaiter.cancelled) break; // timeout + } } - return ec;*/ - assert(false); + return ec; } - private static bool emitForThisThread(ThreadWaiter* waiters, EmitMode mode) + private static bool emitForThisThread(LocalWaiter* waiters, EmitMode mode) nothrow { if (!waiters) return false; @@ -896,9 +929,9 @@ struct ManualEvent { return true; } - private void acquireWaiter(ref Waiter w, ref ThreadWaiter tw) + private void acquireWaiter(ref ThreadWaiter w, ref LocalWaiter tw) nothrow { - // FIXME: this doesn't work! if task a starts to wait, task b afterwards, and then a finishes its wait before b, the Waiter will be dangling + // FIXME: this doesn't work! if task a starts to wait, task b afterwards, and then a finishes its wait before b, the ThreadWaiter will be dangling tw.task = Task.getThis(); if (m_waiters) { @@ -908,18 +941,28 @@ struct ManualEvent { } } - private void acquireWaiter(ref shared(Waiter) w, ref ThreadWaiter tw) + private void acquireWaiter(ref shared(ThreadWaiter) w, ref LocalWaiter tw) nothrow shared { tw.task = Task.getThis(); if (ms_threadEvent == EventID.init) ms_threadEvent = eventDriver.createEvent(); + auto sdriver = cast(shared)eventDriver; + if (m_waiters) { - //m_waiters.tasks.add(&tw); - assert(false); + shared(ThreadWaiter)* pw = m_waiters; + while (pw !is null) { + if (pw.driver is sdriver) { + (cast(ThreadWaiter*)pw).tasks.add(&tw); + break; + } + pw = atomicLoad(pw.next); + } } else { m_waiters = &w; + w.event = ms_threadEvent; + w.driver = sdriver; } } }