public async Task ReliableTest()
{
try {
using (var timeout = new CancellationTokenSource(10000)) {
var str = CreatePlaceholder <string>();
var latch = new AsyncLatch();
var router = receiverFacade.InboundMessageRouter;
router.RegisterHandler <string>(async x => {
await TaskEx.YieldToThreadPool();
AssertEquals(str, x.Body);
latch.Set();
});
await receiverFacade.PeerTable.GetOrAdd(senderFacade.Identity.Id).WaitForDiscoveryAsync(timeout.Token).ConfigureAwait(false);
await senderFacade.PeerTable.GetOrAdd(receiverFacade.Identity.Id).WaitForDiscoveryAsync(timeout.Token).ConfigureAwait(false);
await senderFacade.Messenger.SendReliableAsync(str, receiverFacade.Identity.Id).ConfigureAwait(false);
await latch.WaitAsync(timeout.Token).ConfigureAwait(false);
}
} catch (Exception e) {
Console.WriteLine("Threw " + e);
throw;
} finally {
await receiverFacade.ShutdownAsync().ConfigureAwait(false);
await senderFacade.ShutdownAsync().ConfigureAwait(false);
AssertEquals(0, receiverFacade.RoutingTable.Enumerate().Count());
AssertEquals(0, senderFacade.RoutingTable.Enumerate().Count());
}
}
public async Task ReliableTest() {
try {
using (var timeout = new CancellationTokenSource(10000)) {
var str = CreatePlaceholder<string>();
var latch = new AsyncLatch();
var router = receiverFacade.InboundMessageRouter;
router.RegisterHandler<string>(async x => {
await TaskEx.YieldToThreadPool();
AssertEquals(str, x.Body);
latch.Set();
});
await receiverFacade.PeerTable.GetOrAdd(senderFacade.Identity.Id).WaitForDiscoveryAsync(timeout.Token).ConfigureAwait(false);
await senderFacade.PeerTable.GetOrAdd(receiverFacade.Identity.Id).WaitForDiscoveryAsync(timeout.Token).ConfigureAwait(false);
await senderFacade.Messenger.SendReliableAsync(str, receiverFacade.Identity.Id).ConfigureAwait(false);
await latch.WaitAsync(timeout.Token).ConfigureAwait(false);
}
} catch (Exception e) {
Console.WriteLine("Threw " + e);
throw;
} finally {
await receiverFacade.ShutdownAsync().ConfigureAwait(false);
await senderFacade.ShutdownAsync().ConfigureAwait(false);
AssertEquals(0, receiverFacade.RoutingTable.Enumerate().Count());
AssertEquals(0, senderFacade.RoutingTable.Enumerate().Count());
}
}
private async Task SendHelperAsync(Guid destination, MessageDto message, bool reliable)
{
var packetDto = PacketDto.Create(identity.Id, destination, message, reliable);
var ms = outboundPacketMemoryStreamPool.TakeObject();
ms.SetLength(0);
try {
await AsyncSerialize.ToAsync(ms, packetDto).ConfigureAwait(false);
} catch (NotSupportedException) {
// surpassed memory stream buffer size.
if (!reliable)
{
throw new InvalidOperationException("Attempted to send nonreliable buffer surpassing transport buffer size");
}
ms.SetLength(0);
outboundPacketMemoryStreamPool.ReturnObject(ms);
await SendReliableMultipartPacketAsync(destination, packetDto).ConfigureAwait(false);
#if DEBUG
Interlocked.Increment(ref DebugRuntimeStats.out_rs_done);
#endif
return;
}
if (reliable)
{
var completionSignal = new AsyncLatch();
var acknowlewdgementSignal = acknowledgementCoordinator.Expect(packetDto.Id);
unhandledSendRequestQueue.Enqueue(
new SendRequest {
DataBufferPool = outboundPacketMemoryStreamPool,
Data = ms,
DataOffset = 0,
DataLength = (int)ms.Position,
IsReliable = true,
AcknowledgementSignal = acknowlewdgementSignal,
AcknowledgementGuid = packetDto.Id,
CompletionSignal = completionSignal
});
workSignal.Set();
await completionSignal.WaitAsync().ConfigureAwait(false);
}
else
{
unhandledSendRequestQueue.Enqueue(
new SendRequest {
DataBufferPool = outboundPacketMemoryStreamPool,
Data = ms,
DataOffset = 0,
DataLength = (int)ms.Position,
IsReliable = false
});
workSignal.Set();
}
}
public async Task RunAsync() {
Console.WriteLine(DateTime.Now);
const int kMessagesPerWorker = 200000;
var sink = courierFacades[0];
var senders = courierFacades.Skip(1).ToArray();
var counter = kMessagesPerWorker * senders.Length;
var doneSignal = new AsyncLatch();
int upCounter = 0;
var set = new ConcurrentSet<int>();
sink.InboundMessageRouter.RegisterHandler<string>(
x => {
set.AddOrThrow(int.Parse(x.Body));
var newCounter = Interlocked.Decrement(ref counter);
Interlocked.Increment(ref upCounter);
if (upCounter % 500 == 0)
Console.WriteLine(newCounter + " " + upCounter);
if (newCounter == 0) {
doneSignal.Set();
}
return Task.FromResult(false);
});
var sync = new AsyncCountdownLatch(senders.Length);
var senderTasks = senders.Select((s, id) => Go(async () => {
await s.PeerTable.GetOrAdd(sink.Identity.Id).WaitForDiscoveryAsync().ConfigureAwait(false);
sync.Signal();
await sync.WaitAsync().ConfigureAwait(false);
Console.WriteLine("Sink discovered: " + DateTime.Now);
const int kBatchFactor = 1;
for (var batch = 0; batch < kBatchFactor; batch++) {
var batchSize = kMessagesPerWorker / kBatchFactor;
await Task.WhenAll(Util.Generate(
batchSize,
i => s.Messenger.SendReliableAsync(
"" + (batch * batchSize + i + id * kMessagesPerWorker),
sink.Identity.Id))
).ConfigureAwait(false);
}
Console.WriteLine("Worker Done: " + DateTime.Now);
}));
await Task.WhenAll(senderTasks).ConfigureAwait(false);
Console.WriteLine("Senders Done: " + DateTime.Now);
await doneSignal.WaitAsync().ConfigureAwait(false);
Console.WriteLine("Done Signalled: " + DateTime.Now);
AssertCollectionDeepEquals(set, new ConcurrentSet<int>(Enumerable.Range(0, kMessagesPerWorker * senders.Length)));
while (true) {
GC.Collect();
}
}
public async Task LargeObjectTest()
{
try {
ThreadPool.SetMinThreads(128, 128);
var sw = new Stopwatch();
sw.Start();
logger.Info("Building large payload");
var payload = new byte[1000 * 1000 * 1000];
logger.Info($"Done building large payload. Size: {payload.Length / (1024f * 1024f)} MiB.");
using (var timeout = new CancellationTokenSource(1000000)) {
// ensure the serialized object is large.
var readCompletionLatch = new AsyncLatch();
var router = receiverFacade.InboundMessageRouter;
router.RegisterHandler <byte[]>(async x => {
await TaskEx.YieldToThreadPool();
logger.Info("Received large payload.");
var equalityCheckResult = Util.ByteArraysEqual(payload, x.Body);
logger.Info("Validation result: " + equalityCheckResult);
AssertTrue(equalityCheckResult);
logger.Info("Validated large payload.");
readCompletionLatch.Set();
});
await receiverFacade.PeerTable.GetOrAdd(senderFacade.Identity.Id).WaitForDiscoveryAsync(timeout.Token);
await senderFacade.PeerTable.GetOrAdd(receiverFacade.Identity.Id).WaitForDiscoveryAsync(timeout.Token);
logger.Info("Sending large payload");
await senderFacade.Messenger.SendReliableAsync(payload, receiverFacade.Identity.Id);
logger.Info("Sent large payload");
await readCompletionLatch.WaitAsync(timeout.Token);
}
} catch (Exception e) {
Console.WriteLine("Threw " + e);
throw;
} finally {
await receiverFacade.ShutdownAsync();
await senderFacade.ShutdownAsync();
AssertEquals(0, receiverFacade.RoutingTable.Enumerate().Count());
AssertEquals(0, senderFacade.RoutingTable.Enumerate().Count());
}
}
public void SetIsClosed(bool value)
{
lock (synchronization) {
if (isClosed == value)
{
return;
}
isClosed = value;
if (value)
{
latch.Set();
}
else
{
latch = new AsyncLatch();
}
}
}
public UdpMessagingLoadTests()
{
Go(async() => {
var ch = new BlockingChannel <string>();
var l = new AsyncLatch();
Go(async() => {
await l.WaitAsync().ConfigureAwait(false);
for (var i = 0; i < 10; i++)
{
await ch.WriteAsync("asdf").ConfigureAwait(false);
await Task.Delay(400).ConfigureAwait(false);
}
}).Forget();
l.Set();
for (var i = 0; i < 10; i++)
{
await new Select {
Case(Time.After(500), () => {
Console.WriteLine("Nay!");
}),
Case(ch, () => {
Console.WriteLine("Yay!");
})
}.WaitAsync().ConfigureAwait(false);
}
while (true)
{
;
}
}).Wait();
var courierFacades = Util.Generate(
2,
i => CourierBuilder.Create()
.UseUdpTransport()
.UseTcpServerTransport(21337 + i)
.BuildAsync().Result);
Setup(courierFacades);
}
private async Task SendHelperAsync(Guid destination, MessageDto message)
{
Debug(
$"Sending to {destination.ToString("n").Substring(0, 6)} message {message}. " + Environment.NewLine +
$"clientIdentity matches destination: {remoteIdentity.Matches(destination, IdentityMatchingScope.Broadcast)}");
if (!isHandshakeComplete || !remoteIdentity.Matches(destination, IdentityMatchingScope.Broadcast))
{
return;
}
var completionLatch = new AsyncLatch();
sendCompletionLatchByMessage.AddOrThrow(message, completionLatch);
outboundMessageQueue.Enqueue(message);
outboundMessageSignal.Release();
Debug($"Awaiting completion for send to {destination.ToString("n").Substring(0, 6)} message {message}.");
await completionLatch.WaitAsync().ConfigureAwait(false);
sendCompletionLatchByMessage.RemoveOrThrow(message, completionLatch);
Debug($"Completed send to {destination.ToString("n").Substring(0, 6)} message {message}.");
}
public async Task RunAsync()
{
Console.WriteLine(DateTime.Now);
const int kMessagesPerWorker = 200000;
var sink = courierFacades[0];
var senders = courierFacades.Skip(1).ToArray();
var counter = kMessagesPerWorker * senders.Length;
var doneSignal = new AsyncLatch();
int upCounter = 0;
var set = new ConcurrentSet <int>();
sink.InboundMessageRouter.RegisterHandler <string>(
x => {
set.AddOrThrow(int.Parse(x.Body));
var newCounter = Interlocked.Decrement(ref counter);
Interlocked.Increment(ref upCounter);
if (upCounter % 500 == 0)
{
Console.WriteLine(newCounter + " " + upCounter);
}
if (newCounter == 0)
{
doneSignal.Set();
}
return(Task.FromResult(false));
});
var sync = new AsyncCountdownLatch(senders.Length);
var senderTasks = senders.Select((s, id) => Go(async() => {
await s.PeerTable.GetOrAdd(sink.Identity.Id).WaitForDiscoveryAsync().ConfigureAwait(false);
sync.Signal();
await sync.WaitAsync().ConfigureAwait(false);
Console.WriteLine("Sink discovered: " + DateTime.Now);
const int kBatchFactor = 1;
for (var batch = 0; batch < kBatchFactor; batch++)
{
var batchSize = kMessagesPerWorker / kBatchFactor;
await Task.WhenAll(Util.Generate(
batchSize,
i => s.Messenger.SendReliableAsync(
"" + (batch * batchSize + i + id * kMessagesPerWorker),
sink.Identity.Id))
).ConfigureAwait(false);
}
Console.WriteLine("Worker Done: " + DateTime.Now);
}));
await Task.WhenAll(senderTasks).ConfigureAwait(false);
Console.WriteLine("Senders Done: " + DateTime.Now);
await doneSignal.WaitAsync().ConfigureAwait(false);
Console.WriteLine("Done Signalled: " + DateTime.Now);
AssertCollectionDeepEquals(set, new ConcurrentSet <int>(Enumerable.Range(0, kMessagesPerWorker * senders.Length)));
while (true)
{
GC.Collect();
}
}
public UdpMessagingLoadTests() {
Go(async () => {
var ch = new BlockingChannel<string>();
var l = new AsyncLatch();
Go(async () => {
await l.WaitAsync().ConfigureAwait(false);
for (var i = 0; i < 10; i++) {
await ch.WriteAsync("asdf").ConfigureAwait(false);
await Task.Delay(400).ConfigureAwait(false);
}
}).Forget();
l.Set();
for (var i = 0; i < 10; i++) {
await new Select {
Case(Time.After(500), () => {
Console.WriteLine("Nay!");
}),
Case(ch, () => {
Console.WriteLine("Yay!");
})
}.WaitAsync().ConfigureAwait(false);
}
while (true) ;
}).Wait();
var courierFacades = Util.Generate(
2,
i => CourierBuilder.Create()
.UseUdpTransport()
.UseTcpServerTransport(21337 + i)
.BuildAsync().Result);
Setup(courierFacades);
}
private async Task SendHelperAsync(Guid destination, MessageDto message) {
Debug(
$"Sending to {destination.ToString("n").Substring(0, 6)} message {message}. " + Environment.NewLine +
$"clientIdentity matches destination: {remoteIdentity.Matches(destination, IdentityMatchingScope.Broadcast)}");
if (!isHandshakeComplete || !remoteIdentity.Matches(destination, IdentityMatchingScope.Broadcast)) {
return;
}
var completionLatch = new AsyncLatch();
sendCompletionLatchByMessage.AddOrThrow(message, completionLatch);
outboundMessageQueue.Enqueue(message);
outboundMessageSignal.Release();
Debug($"Awaiting completion for send to {destination.ToString("n").Substring(0, 6)} message {message}.");
await completionLatch.WaitAsync().ConfigureAwait(false);
sendCompletionLatchByMessage.RemoveOrThrow(message, completionLatch);
Debug($"Completed send to {destination.ToString("n").Substring(0, 6)} message {message}.");
}
public async Task LargeObjectTest() {
try {
ThreadPool.SetMinThreads(128, 128);
var sw = new Stopwatch();
sw.Start();
logger.Info("Building large payload");
var payload = new byte[1000 * 1000 * 1000];
logger.Info($"Done building large payload. Size: {payload.Length / (1024f * 1024f)} MiB." );
using (var timeout = new CancellationTokenSource(1000000)) {
// ensure the serialized object is large.
var readCompletionLatch = new AsyncLatch();
var router = receiverFacade.InboundMessageRouter;
router.RegisterHandler<byte[]>(async x => {
await TaskEx.YieldToThreadPool();
logger.Info("Received large payload.");
var equalityCheckResult = Util.ByteArraysEqual(payload, x.Body);
logger.Info("Validation result: " + equalityCheckResult);
AssertTrue(equalityCheckResult);
logger.Info("Validated large payload.");
readCompletionLatch.Set();
});
await receiverFacade.PeerTable.GetOrAdd(senderFacade.Identity.Id).WaitForDiscoveryAsync(timeout.Token);
await senderFacade.PeerTable.GetOrAdd(receiverFacade.Identity.Id).WaitForDiscoveryAsync(timeout.Token);
logger.Info("Sending large payload");
await senderFacade.Messenger.SendReliableAsync(payload, receiverFacade.Identity.Id);
logger.Info("Sent large payload");
await readCompletionLatch.WaitAsync(timeout.Token);
}
} catch (Exception e) {
Console.WriteLine("Threw " + e);
throw;
} finally {
await receiverFacade.ShutdownAsync();
await senderFacade.ShutdownAsync();
AssertEquals(0, receiverFacade.RoutingTable.Enumerate().Count());
AssertEquals(0, senderFacade.RoutingTable.Enumerate().Count());
}
}
