// this is a sync-over-async; don't do it
// [Benchmark(OperationsPerInvoke = CC_LOAD * CC_LOAD)]
public async Task <int> AsyncSemaphore_ConcurrentLoad()
{
var tasks = Enumerable.Range(0, CC_LOAD).Select(async _ =>
{
int success = 0;
for (int t = 0; t < CC_LOAD; t++)
{
_asyncSemaphore.Wait();
try
{
success++;
await Task.Yield();
}
finally
{
_asyncSemaphore.Release();
}
await Task.Yield();
}
return(success);
}).ToArray();
await Task.WhenAll(tasks).ConfigureAwait(false);
int total = tasks.Sum(x => x.Result);
return(total.AssertIs(CC_LOAD * CC_LOAD));
}
internal static TResult Implementation <TResult>(
Func <CancellationToken, TResult> action,
Context context,
Action <Context> onBulkheadRejected,
SemaphoreSlim maxParallelizationSemaphore,
SemaphoreSlim maxQueuedActionsSemaphore,
CancellationToken cancellationToken)
{
if (!maxQueuedActionsSemaphore.Wait(TimeSpan.Zero, cancellationToken))
{
onBulkheadRejected(context);
throw new BulkheadRejectedException();
}
try
{
maxParallelizationSemaphore.Wait(cancellationToken);
try
{
return(action(cancellationToken));
}
finally
{
maxParallelizationSemaphore.Release();
}
}
finally
{
maxQueuedActionsSemaphore.Release();
}
}