public async Task CustomProcessTestAsync()
{
await TaskEx.YieldToThreadPool();
ThreadPool.SetMaxThreads(128, 128);
var cohortCount = 4;
var cluster = await TestUtils.CreateCluster <int, SetBox <int> >(cohortCount).ConfigureAwait(false);
var workerCount = 100;
var sync = new AsyncCountdownLatch(workerCount);
var tasks = Util.Generate(
workerCount,
value => ChannelsExtensions.Go(async() => {
sync.Signal();
await sync.WaitAsync().ConfigureAwait(false);
var node = cluster[value % cohortCount];
var result = await node.UserCache.ProcessAsync(0, SetAddEntryOperation <int, int> .Create(value)).ConfigureAwait(false);
AssertTrue(result);
}));
try {
await Task.WhenAll(tasks).ConfigureAwait(false);
Console.WriteLine("Validating set contents");
var result = await cluster[0].UserCache.GetAsync(0).ConfigureAwait(false);
AssertCollectionDeepEquals(new HashSet <int>(Enumerable.Range(0, 100)), result.Value.Set);
} catch (Exception e) {
Console.Error.WriteLine("Test threw " + e);
throw;
}
}
public async Task RunAsync()
{
var cachePersistenceStrategy = new NullCachePersistenceStrategy <int, int>();
var operationDiagnosticsTable = new NullOperationDiagnosticsTable();
var keyCount = 100;
var operationsPerKey = 50000;
var singletons = Util.Generate(keyCount, i => new CacheRoot <int, int> .SomethingToDoWithEntryOperationChuggingAbstractBeanFactorySingleton(i, cachePersistenceStrategy, operationDiagnosticsTable));
var readyLatch = new AsyncCountdownLatch(keyCount);
var completionLatch = new AsyncCountdownLatch(keyCount);
Console.WriteLine(DateTime.Now + " Begin Queue.");
Util.Generate(keyCount, key => Go(async() => {
await TaskEx.YieldToThreadPool();
var executionContexts = Util.Generate(operationsPerKey, i => singletons[key].EnqueueOperationAndGetExecutionContext <int>(key, GetKeythPlus1000thFib.Create()));
if (readyLatch.Signal())
{
Console.WriteLine(DateTime.Now + " Go!");
}
await readyLatch.WaitAsync().ConfigureAwait(false);
await singletons[key].InitializeAsync().ConfigureAwait(false);
await Task.WhenAll(executionContexts.Map(ec => ec.ResultBox.GetResultAsync())).ConfigureAwait(false);
completionLatch.Signal();
}));
await completionLatch.WaitAsync().ConfigureAwait(false);
Console.WriteLine(DateTime.Now + " Done!");
}
public async Task PutTestAsync()
{
await TaskEx.YieldToThreadPool();
ThreadPool.SetMaxThreads(128, 128);
var cohortCount = 4;
var cluster = await TestUtils.CreateCluster <int, string>(cohortCount).ConfigureAwait(false);
var workerCount = 100;
var sync = new AsyncCountdownLatch(workerCount);
var tasks = Util.Generate(
workerCount,
key => Go(async() => {
try {
Console.WriteLine("Entered thread for worker of key " + key);
sync.Signal();
await sync.WaitAsync().ConfigureAwait(false);
const int kWriteCount = 10;
for (var i = 0; i < kWriteCount; i++)
{
var node = cluster[i % cohortCount];
var previousEntry = await node.UserCache.PutAsync(key, "value" + i).ConfigureAwait(false);
AssertEquals(key, previousEntry.Key);
if (i == 0)
{
AssertNull(previousEntry.Value);
AssertFalse(previousEntry.Exists);
}
else
{
AssertEquals("value" + (i - 1), previousEntry.Value);
AssertTrue(previousEntry.Exists);
}
}
{
var node = cluster[kWriteCount % cohortCount];
var currentEntry = await node.UserCache.GetAsync(key).ConfigureAwait(false);
AssertEquals(key, currentEntry.Key);
AssertEquals("value" + (kWriteCount - 1), currentEntry.Value);
AssertEquals(true, currentEntry.Exists);
}
} catch (Exception e) {
Console.Error.WriteLine("Worker on key " + key + " threw " + e);
throw;
}
}));
try {
await Task.WhenAll(tasks).ConfigureAwait(false);
} catch (Exception e) {
Console.Error.WriteLine("Test threw " + e);
throw;
}
}
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 PutTestAsync() {
await TaskEx.YieldToThreadPool();
ThreadPool.SetMaxThreads(128, 128);
var cohortCount = 4;
var cluster = await TestUtils.CreateCluster<int, string>(cohortCount).ConfigureAwait(false);
var workerCount = 100;
var sync = new AsyncCountdownLatch(workerCount);
var tasks = Util.Generate(
workerCount,
key => Go(async () => {
try {
Console.WriteLine("Entered thread for worker of key " + key);
sync.Signal();
await sync.WaitAsync().ConfigureAwait(false);
const int kWriteCount = 10;
for (var i = 0; i < kWriteCount; i++) {
var node = cluster[i % cohortCount];
var previousEntry = await node.UserCache.PutAsync(key, "value" + i).ConfigureAwait(false);
AssertEquals(key, previousEntry.Key);
if (i == 0) {
AssertNull(previousEntry.Value);
AssertFalse(previousEntry.Exists);
} else {
AssertEquals("value" + (i - 1), previousEntry.Value);
AssertTrue(previousEntry.Exists);
}
}
{
var node = cluster[kWriteCount % cohortCount];
var currentEntry = await node.UserCache.GetAsync(key).ConfigureAwait(false);
AssertEquals(key, currentEntry.Key);
AssertEquals("value" + (kWriteCount - 1), currentEntry.Value);
AssertEquals(true, currentEntry.Exists);
}
} catch (Exception e) {
Console.Error.WriteLine("Worker on key " + key + " threw " + e);
throw;
}
}));
try {
await Task.WhenAll(tasks).ConfigureAwait(false);
} catch (Exception e) {
Console.Error.WriteLine("Test threw " + e);
throw;
}
}
public async Task RunAsync()
{
await TaskEx.YieldToThreadPool();
ThreadPool.SetMaxThreads(128, 128);
var cohortCount = 4;
var cluster = await TestUtils.CreateCluster <int, string>(cohortCount).ConfigureAwait(false);
var workerCount = 100;
var sync = new AsyncCountdownLatch(workerCount);
var tasks = Util.Generate(
workerCount,
key => ChannelsExtensions.Go(async() => {
try {
Console.WriteLine("Entered thread for worker of key " + key);
sync.Signal();
await sync.WaitAsync().ConfigureAwait(false);
const int kReadCount = 10;
for (var i = 0; i < kReadCount; i++)
{
var node = cluster[i % cohortCount];
var entry = await node.UserCache.GetAsync(key).ConfigureAwait(false);
AssertEquals(key, entry.Key);
AssertEquals(null, entry.Value);
AssertFalse(entry.Exists);
}
} catch (Exception e) {
Console.Error.WriteLine("Worker on key " + key + " threw " + e);
throw;
}
}));
try {
await Task.WhenAll(tasks).ConfigureAwait(false);
} catch (Exception e) {
Console.Error.WriteLine("Test threw " + e);
throw;
}
}
public async Task RunAsync() {
await TaskEx.YieldToThreadPool();
ThreadPool.SetMaxThreads(128, 128);
var cohortCount = 4;
var cluster = await TestUtils.CreateCluster<int, string>(cohortCount).ConfigureAwait(false);
var workerCount = 100;
var sync = new AsyncCountdownLatch(workerCount);
var tasks = Util.Generate(
workerCount,
key => ChannelsExtensions.Go(async () => {
try {
Console.WriteLine("Entered thread for worker of key " + key);
sync.Signal();
await sync.WaitAsync().ConfigureAwait(false);
const int kReadCount = 10;
for (var i = 0; i < kReadCount; i++) {
var node = cluster[i % cohortCount];
var entry = await node.UserCache.GetAsync(key).ConfigureAwait(false);
AssertEquals(key, entry.Key);
AssertEquals(null, entry.Value);
AssertFalse(entry.Exists);
}
} catch (Exception e) {
Console.Error.WriteLine("Worker on key " + key + " threw " + e);
throw;
}
}));
try {
await Task.WhenAll(tasks).ConfigureAwait(false);
} catch (Exception e) {
Console.Error.WriteLine("Test threw " + e);
throw;
}
}
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 RunAsync()
{
int minWorkerThreads, maxWorkerThreads, minCompletionPortThreads, maxCompletionPortThreads;
ThreadPool.GetMinThreads(out minWorkerThreads, out minCompletionPortThreads);
ThreadPool.GetMaxThreads(out maxWorkerThreads, out maxCompletionPortThreads);
Console.WriteLine($"Test Configuration: workers {minWorkerThreads}/{maxWorkerThreads}, iocp {minCompletionPortThreads}/{maxCompletionPortThreads}");
await TaskEx.YieldToThreadPool();
ThreadPool.SetMaxThreads(128, 128);
await SetupAsync().ConfigureAwait(false);
var sw = new Stopwatch();
sw.Start();
Console.WriteLine(sw.ElapsedMilliseconds + " Starting Cluster");
var cluster = await TestUtils.CreateCluster <int, TestDto>(
clusterSize,
() => new CacheConfiguration <int, TestDto>("test-cache") {
CachePersistenceStrategy = CachePersistenceStrategy <int, TestDto> .Create(
BatchedCacheReadStrategy <int, TestDto> .Create(hitler),
WriteBehindCacheUpdateStrategy <int, TestDto> .Create(hitler, 5000)),
PartitioningConfiguration = new PartitioningConfiguration {
Redundancy = replicationFactor
}
}).ConfigureAwait(false);
Console.WriteLine(sw.ElapsedMilliseconds + " Started Cluster");
var sync = new AsyncCountdownLatch(workerCount);
var tasks = Util.Generate(
workerCount,
async workerId => {
await TaskEx.YieldToThreadPool();
sync.Signal();
await sync.WaitAsync().ConfigureAwait(false);
var jobs = Util.Generate(
rowCount * iterationsPerWorker,
i => cluster[(workerId + i) % clusterSize].UserCache.ProcessAsync(
entryIdsByOriginalName["Name" + (i % rowCount)],
AppendToNameOperation.Create("_")
));
Console.WriteLine(DateTime.Now + " Worker " + workerId + " started iterations");
await Task.WhenAll(jobs).ConfigureAwait(false);
Console.WriteLine(DateTime.Now + " Worker " + workerId + " completed iterations");
});
try {
Console.WriteLine(sw.ElapsedMilliseconds + " Awaiting workers");
await Task.WhenAll(tasks).ConfigureAwait(false);
Console.WriteLine(sw.ElapsedMilliseconds + " Validating cache state");
await Task.WhenAll(
Util.Generate(
rowCount,
i => Go(async() => {
var originalName = "Name" + i;
var entryId = entryIdsByOriginalName[originalName];
var entry = await cluster[i % clusterSize].UserCache.GetAsync(entryId).ConfigureAwait(false);
AssertEquals(originalName + "_".Repeat(workerCount *iterationsPerWorker), entry.Value.Name);
}))).ConfigureAwait(false);
Console.WriteLine(sw.ElapsedMilliseconds + " Validation completed");
await CleanupAsync().ConfigureAwait(false);
while (true)
{
;
}
} catch (Exception e) {
Console.WriteLine("Write behind test threw " + e);
throw;
}
}
