public void RemoveParticipantsAsync_Underflow_ThrowsException()
{
var barrier = new AsyncBarrier(2);
barrier.SignalAndWaitAsync();
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.RemoveParticipantsAsync(2));
}
public async Task StressMultipleGroups(int players, int groupSize)
{
var barrier = new AsyncBarrier(groupSize);
var playerTasks = new Task[players];
int signalsCount = 0;
using (var cts = new CancellationTokenSource(300))
{
for (int i = 0; i < playerTasks.Length; i++)
{
playerTasks[i] = Task.Run(async delegate
{
while (!cts.Token.IsCancellationRequested)
{
Interlocked.Increment(ref signalsCount);
await barrier.SignalAndWait().WithCancellation(cts.Token).NoThrowAwaitable();
}
});
}
await Task.WhenAll(playerTasks).WithTimeout(UnexpectedTimeout);
}
this.Logger.WriteLine("Test reached {0} signals.", signalsCount);
}
Task DoReqRep(string url)
{
var barrier = new AsyncBarrier(2);
var dialUrl = string.Empty;
var rep = Task.Run(async() =>
{
using (var socket = Factory.ReplierOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await barrier.SignalAndWait();
var msg = await ctx.Receive();
(await ctx.Reply(Factory.CreateMessage())).Unwrap();
await WaitShort();
}
});
var req = Task.Run(async() =>
{
await barrier.SignalAndWait();
using (var socket = Factory.RequesterOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
var _response = await ctx.Send(Factory.CreateMessage());
}
});
return(Util.AssertWait(req, rep));
}
static void TryAsyncBarrier()
{
const int participantCount = 5;
var asyncBarrier = new AsyncBarrier(participantCount, () => Console.WriteLine("AsyncBarrier is being reset!"));
for (int i = 0; i < participantCount + 1; i++)
{
var temp = i + 1;
Task.Factory.StartNew(async() =>
{
try
{
//await Task.Delay(temp * 1000);
Console.WriteLine($"Participant {temp} signalling and waiting!");
await asyncBarrier.SignalAndWait();
Console.WriteLine($"Participant {temp} is now awake!");
await Task.Delay(1000);
Console.WriteLine($"Participant {temp} signalling and waiting for the second time!");
await asyncBarrier.SignalAndWait();
Console.WriteLine($"Participant {temp} has awoken yet again!");
}
catch (Exception e)
{
Console.WriteLine($"Participant {temp} has encountered the following exception: {e.Message}");
}
});
}
}
void ITraceEnlightenment.AsyncBarrier_ParticipantsChanged(AsyncBarrier barrier, long phase, int participants)
{
if (IsEnabled(EventLevel.Verbose, Keywords.AsyncSynchronization))
{
AsyncBarrierParticipantsChanged(barrier.Id, Task.CurrentId ?? 0, phase, participants);
}
}
void ITraceEnlightenment.AsyncBarrier_CountChanged(AsyncBarrier barrier, long phase, int count)
{
if (IsEnabled(EventLevel.Verbose, Keywords.AsyncSynchronization))
{
AsyncBarrierCountChanged(barrier.Id, Task.CurrentId ?? 0, phase, count);
}
}
Task DoPushPull(string url)
{
var serverReady = new AsyncBarrier(2);
var clientReady = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var dialUrl = string.Empty;
var push = Task.Run(async() =>
{
using (var socket = Factory.PusherOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await serverReady.SignalAndWait();
await clientReady.SignalAndWait();
(await ctx.Send(Factory.CreateMessage())).Unwrap();
}
});
var pull = Task.Run(async() =>
{
await serverReady.SignalAndWait();
using (var socket = Factory.PullerOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
var task = ctx.Receive(cts.Token);
await WaitShort();
await clientReady.SignalAndWait();
var _ = await task;
}
});
return(CancelAfterAssertwait(cts, pull, push));
}
Task DoPubSub(string url)
{
var topic = TopicRandom();
var serverReady = new AsyncBarrier(2);
var clientReady = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var pubTask = Task.Run(async() =>
{
using (var pubSocket = Factory.PublisherCreate(url).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await serverReady.SignalAndWait();
await clientReady.SignalAndWait();
await WaitReady();
Assert.True(await pubSocket.Send(Factory.CreateTopicMessage(topic)));
await WaitShort();
}
});
var subTask = Task.Run(async() =>
{
await serverReady.SignalAndWait();
using (var sub = Factory.SubscriberCreate(url).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
sub.Subscribe(topic);
await clientReady.SignalAndWait();
await sub.Receive(cts.Token);
}
});
cts.CancelAfter(DefaultTimeoutMs);
return(Task.WhenAll(pubTask, subTask));
}
async Task DoSendRecvNonBlockTasks(string url)
{
var dialUrl = String.Empty;
var barrier = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var flags = Defines.NngFlag.NNG_FLAG_NONBLOCK;
var rep = Task.Run(async() => {
using (var rep = Factory.ReplierOpen().ThenListenAs(out var listener, url).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await barrier.SignalAndWait();
var msg = Factory.CreateMessage();
var request = (await RetryAgain(cts, () => rep.RecvMsg(flags))).Unwrap();
var res = await RetryAgain(cts, () => rep.SendMsg(request, flags));
res.Unwrap();
}
});
var req = Task.Run(async() => {
await barrier.SignalAndWait();
using (var req = Factory.RequesterOpen().ThenDial(dialUrl).Unwrap())
{
var msg = Factory.CreateMessage();
var res = await RetryAgain(cts, () => req.SendMsg(msg, flags));
res.Unwrap();
var reply = await RetryAgain(cts, () => req.RecvMsg(flags));
var _ = reply.Unwrap();
}
});
await Util.CancelAfterAssertwait(cts, req, rep);
}
Task DoPubSub(string url)
{
var topic = TopicRandom();
var serverReady = new AsyncBarrier(2);
var clientReady = new AsyncBarrier(2);
var cts = new CancellationTokenSource();
var dialUrl = string.Empty;
var pubTask = Task.Run(async() =>
{
using (var socket = Factory.PublisherOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await serverReady.SignalAndWait();
await clientReady.SignalAndWait();
// Give receivers a chance to actually start receiving
await WaitShort();
(await ctx.Send(Factory.CreateTopicMessage(topic))).Unwrap();
}
});
var subTask = Task.Run(async() =>
{
await serverReady.SignalAndWait();
using (var socket = Factory.SubscriberOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
ctx.Subscribe(topic);
await clientReady.SignalAndWait();
await ctx.Receive(cts.Token);
}
});
return(CancelAfterAssertwait(cts, pubTask, subTask));
}
private async Task MultipleParticipantsHelperAsync(int participants, int steps)
{
Requires.Range(participants > 0, "participants");
Requires.Range(steps > 0, "steps");
var barrier = new AsyncBarrier(1 + participants); // 1 for test coordinator
int[] currentStepForActors = new int[participants];
Task[] actorsFinishedTasks = new Task[participants];
var actorReady = new AsyncAutoResetEvent();
for (int i = 0; i < participants; i++)
{
int participantIndex = i;
var progress = new Progress <int>(step =>
{
currentStepForActors[participantIndex] = step;
actorReady.Set();
});
actorsFinishedTasks[i] = this.ActorAsync(barrier, steps, progress);
}
for (int i = 1; i <= steps; i++)
{
// Wait until all actors report having completed this step.
while (!currentStepForActors.All(step => step == i))
{
// Wait for someone to signal a change has been made to the array.
await actorReady.WaitAsync();
}
// Give the last signal to proceed to the next step.
await barrier.SignalAndWait();
}
}
public void Run_AsyncBarrier()
{
var asyncBarrier = new AsyncBarrier(InitialParticipantCount);
Assert.AreEqual(InitialParticipantCount, asyncBarrier.ParticipantCount);
var task = asyncBarrier.SignalAndWait();
while (task.IsCompleted == false)
{
if (IsDebugEnabled)
{
log.Debug("AsyncBarrier# RemainingCount={0}, ParticipantCount={1}, IsCompleted={2}",
asyncBarrier.RemainingCount, asyncBarrier.ParticipantCount, task.IsCompleted);
}
Assert.IsFalse(task.IsCanceled);
Assert.IsFalse(task.IsFaulted);
task = asyncBarrier.SignalAndWait();
}
// Participant가 모두 없어졌으면 Task는 완료되었다고 본다.
//
Assert.IsTrue(task.IsCompleted);
if (IsDebugEnabled)
{
log.Debug("AsyncBarrier# RemainingCount={0}, ParticipantCount={1}, IsCompleted={2}",
asyncBarrier.RemainingCount, asyncBarrier.ParticipantCount, task.IsCompleted);
}
}
Task DoReqRep(string url)
{
var barrier = new AsyncBarrier(2);
var rep = Task.Run(async() =>
{
using (var repAioCtx = Factory.ReplierCreate(url).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
await barrier.SignalAndWait();
var msg = await repAioCtx.Receive();
(await repAioCtx.Reply(Factory.CreateMessage())).Unwrap();
await WaitShort();
}
});
var req = Task.Run(async() =>
{
await barrier.SignalAndWait();
using (var reqAioCtx = Factory.RequesterCreate(url).Unwrap().CreateAsyncContext(Factory).Unwrap())
{
var _response = await reqAioCtx.Send(Factory.CreateMessage());
}
});
return(Util.AssertWait(req, rep));
}
public void Run_AsyncBarrier() {
var asyncBarrier = new AsyncBarrier(InitialParticipantCount);
Assert.AreEqual(InitialParticipantCount, asyncBarrier.ParticipantCount);
var task = asyncBarrier.SignalAndWait();
while(task.IsCompleted == false) {
if(IsDebugEnabled)
log.Debug("AsyncBarrier# RemainingCount={0}, ParticipantCount={1}, IsCompleted={2}",
asyncBarrier.RemainingCount, asyncBarrier.ParticipantCount, task.IsCompleted);
Assert.IsFalse(task.IsCanceled);
Assert.IsFalse(task.IsFaulted);
task = asyncBarrier.SignalAndWait();
}
// Participant가 모두 없어졌으면 Task는 완료되었다고 본다.
//
Assert.IsTrue(task.IsCompleted);
if(IsDebugEnabled)
log.Debug("AsyncBarrier# RemainingCount={0}, ParticipantCount={1}, IsCompleted={2}",
asyncBarrier.RemainingCount, asyncBarrier.ParticipantCount, task.IsCompleted);
}
async Task DoAdvanced(string url)
{
const int NumSurveyors = 1;
const int NumResponders = 2;
var readyToDial = new AsyncBarrier(NumSurveyors + NumResponders);
var readyToSend = new AsyncBarrier(NumSurveyors + NumResponders);
var numSurveyorReceive = new AsyncCountdownEvent(NumResponders);
var numResponderReceive = new AsyncCountdownEvent(NumResponders);
var cts = new CancellationTokenSource();
var tasks = new List <Task>();
var dialUrl = string.Empty;
var task = Task.Run(async() =>
{
using (var socket = Factory.SurveyorOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await readyToDial.SignalAndWait();
await readyToSend.SignalAndWait();
// Send survey and receive response
await WaitShort();
await ctx.Send(Factory.CreateMessage());
await WaitShort();
while (!cts.IsCancellationRequested)
{
var response = await ctx.Receive(cts.Token);
if (numSurveyorReceive.Signal() == 0)
{
break;
}
}
}
});
tasks.Add(task);
for (int i = 0; i < NumResponders; ++i)
{
task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var socket = Factory.RespondentOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
await readyToSend.SignalAndWait();
// Receive survey and send response
var survey = await ctx.Receive(cts.Token);
numResponderReceive.Signal();
(await ctx.Send(survey.Unwrap())).Unwrap();
await numSurveyorReceive.WaitAsync();
}
});
tasks.Add(task);
}
await Util.AssertWait(tasks);
Assert.Equal(0, numSurveyorReceive.Count);
Assert.Equal(0, numResponderReceive.Count);
}
public void RemoveZeroParticipants_DoesNothing()
{
var barrier = new AsyncBarrier(1);
Assert.AreEqual(1, barrier.ParticipantCount);
barrier.RemoveParticipantsAsync(0);
Assert.AreEqual(1, barrier.ParticipantCount);
}
public void AddZeroParticipants_DoesNothing()
{
var barrier = new AsyncBarrier(1);
Assert.AreEqual(1, barrier.ParticipantCount);
barrier.AddParticipants(0);
Assert.AreEqual(1, barrier.ParticipantCount);
}
public void PostPhaseAction_PropagatesExceptions()
{
AsyncContext.Run(async() =>
{
var barrier = new AsyncBarrier(1, _ => { throw new NotImplementedException(); });
await AssertEx.ThrowsExceptionAsync <NotImplementedException>(barrier.SignalAndWaitAsync(), allowDerivedTypes: false);
});
}
public void SignalAndWaitAsync_NoParticipants_ThrowsException()
{
var barrier = new AsyncBarrier(0);
Assert.AreEqual(0, barrier.CurrentPhaseNumber);
Assert.AreEqual(0, barrier.ParticipantCount);
Assert.AreEqual(0, barrier.ParticipantsRemaining);
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.SignalAndWaitAsync());
}
public void SignalAndWaitAsync_Underflow_ThrowsException()
{
var tcs = new TaskCompletionSource();
var barrier = new AsyncBarrier(1, async _ => { await tcs.Task; });
barrier.SignalAndWaitAsync();
AssertEx.ThrowsException <InvalidOperationException>(() => barrier.SignalAndWaitAsync());
tcs.SetResult();
}
public void WhenBarrierIsNonSignaled_ClientsShouldBeWaitedWithTimeout()
{
var clientCount = 2;
var sut = new AsyncBarrier(clientCount);
var task = sut.SignalAndWaitAsync(TimeSpan.FromMilliseconds(300));
Assert.ThrowsExceptionAsync <TimeoutException>(() => task);
}
public void WhenSignaledClientCountLessThenNecessary_BarrierShouldBeNonSignaled()
{
var clientCount = 3;
var sut = new AsyncBarrier(clientCount);
var task1 = sut.SignalAndWaitAsync();
var task2 = sut.SignalAndWaitAsync();
var tasks = Task.WhenAny(task1, task2);
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(tasks);
}
public void SignalZero_DoesNothing()
{
AsyncContext.Run(async() =>
{
var barrier = new AsyncBarrier(1);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
var task = barrier.SignalAndWaitAsync(0);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
await AssertEx.NeverCompletesAsync(task);
});
}
public void AsyncPostPhaseAction_PropagatesExceptions()
{
Test.Async(async() =>
{
var barrier = new AsyncBarrier(1, async _ =>
{
await TaskShim.Yield();
throw new NotImplementedException();
});
await AssertEx.ThrowsExceptionAsync <NotImplementedException>(barrier.SignalAndWaitAsync(), allowDerivedTypes: false);
});
}
async Task DoAdvanced(string url)
{
var readyToDial = new AsyncBarrier(3);
var readyToSend = new AsyncBarrier(3);
var messageReceipt = new AsyncCountdownEvent(2);
var cts = new CancellationTokenSource();
var dialUrl = string.Empty;
var bus0Task = Task.Run(async() =>
{
using (var socket = Factory.BusOpen().ThenListenAs(out var listener, url).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
dialUrl = GetDialUrl(listener, url);
await readyToDial.SignalAndWait();
await readyToSend.SignalAndWait();
await ctx.Send(Factory.CreateMessage());
// Give it a chance to actually send
await WaitReady();
}
});
var bus1Task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var socket = Factory.BusOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
// Make sure receive has started before signalling ready
var recvFuture = ctx.Receive(cts.Token);
await WaitShort();
await readyToSend.SignalAndWait();
var _ = await recvFuture;
messageReceipt.Signal();
}
});
var bus2Task = Task.Run(async() =>
{
await readyToDial.SignalAndWait();
using (var socket = Factory.BusOpen().ThenDial(dialUrl).Unwrap())
using (var ctx = socket.CreateAsyncContext(Factory).Unwrap())
{
// Make sure receive has started before signalling ready
var recvFuture = ctx.Receive(cts.Token);
await WaitShort();
await readyToSend.SignalAndWait();
var _ = await recvFuture;
messageReceipt.Signal();
}
});
await CancelAfterWait(cts, bus0Task, bus1Task, bus2Task);
Assert.Equal(0, messageReceipt.Count);
}
public void AddParticipants_IncreasesParticipantsForCurrentPhase()
{
var barrier = new AsyncBarrier(1);
Assert.AreEqual(0, barrier.CurrentPhaseNumber);
Assert.AreEqual(1, barrier.ParticipantCount);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
barrier.AddParticipants(2);
Assert.AreEqual(0, barrier.CurrentPhaseNumber);
Assert.AreEqual(3, barrier.ParticipantCount);
Assert.AreEqual(3, barrier.ParticipantsRemaining);
}
public void ItCompletesTheTaskWhenSignalAnsWaitIsCalledSampleTimes()
{
var asyncBarrier = new AsyncBarrier(SampleTimes);
var tasks = new Task[SampleTimes];
for (int i = 0; i < SampleTimes; i++)
{
tasks[i] = asyncBarrier.SignalAndWait();
}
var task = Task.WhenAll(tasks);
task.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(task.IsCompleted);
}
public void PostPhaseAction_ExecutedAtEndOfEachPhase()
{
AsyncContext.Run(async() =>
{
int executed = 0;
var barrier = new AsyncBarrier(1, _ => { Interlocked.Increment(ref executed); });
await barrier.SignalAndWaitAsync();
Assert.AreEqual(1, Interlocked.CompareExchange(ref executed, 0, 0));
await barrier.SignalAndWaitAsync();
Assert.AreEqual(2, Interlocked.CompareExchange(ref executed, 0, 0));
});
}
public void WhenSignaledClientCountEqualToNecessary_BarrierShouldBecomeSignaled()
{
var clientCount = 3;
var sut = new AsyncBarrier(clientCount);
var task1 = sut.SignalAndWaitAsync();
var task2 = sut.SignalAndWaitAsync();
var task3 = sut.SignalAndWaitAsync();
var allTasks = Task.WhenAll(task1, task2, task3);
ConcurrentAssert.EnsureThatTaskIsCompleted(allTasks);
}
public void ItCompletesTheTaskWhenSignalAnsWaitIsCalledSampleTimes()
{
var asyncBarrier = new AsyncBarrier(SampleTimes);
var tasks = new Task[SampleTimes];
for (int i = 0; i < SampleTimes; i++)
{
tasks[i] = asyncBarrier.SignalAndWait();
}
var task = Task.WhenAll(tasks);
task.Wait(TimeSpan.FromSeconds(1));
Assert.IsTrue(task.IsCompleted);
}
public void SignalAndWaitAsync_LastParticipant_CompletesPhase()
{
AsyncContext.Run(async() =>
{
var barrier = new AsyncBarrier(1);
Assert.AreEqual(0, barrier.CurrentPhaseNumber);
Assert.AreEqual(1, barrier.ParticipantCount);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
await barrier.SignalAndWaitAsync();
Assert.AreEqual(1, barrier.CurrentPhaseNumber);
Assert.AreEqual(1, barrier.ParticipantCount);
Assert.AreEqual(1, barrier.ParticipantsRemaining);
});
}
private async Task ActorAsync(AsyncBarrier barrier, int steps, IProgress <int> progress)
{
Requires.NotNull(barrier, nameof(barrier));
Requires.Range(steps >= 0, "steps");
Requires.NotNull(progress, nameof(progress));
for (int i = 1; i <= steps; i++)
{
await Task.Yield();
progress.Report(i);
await barrier.SignalAndWait();
}
}
public void ItReturnsTaskWhenSignalAndWaitIsCalled()
{
var asyncBarrier = new AsyncBarrier(SampleTimes);
Assert.IsInstanceOfType(asyncBarrier.SignalAndWait(), typeof(Task));
}
