private async Task <CallResult[]> ProcessAsync(int requestCount, int waitMilliseonds, CancellationToken ct)
        {
            var data = new LongRunBenchmarkData
            {
                WaitMilliseconds = waitMilliseonds,
            };
            var duration = _config.GetDuration();

            if (duration != TimeSpan.Zero)
            {
                // timeout base
                using var cts       = new CancellationTokenSource(duration);
                using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, ct);
                var linkedCt = linkedCts.Token;

                using var pool = new TaskWorkerPool <LongRunBenchmarkData>(_config.ClientConcurrency, linkedCt);
                pool.RunWorkers((id, data, ct) => GetClient(id).Process(data), data, ct);
                await Task.WhenAny(pool.WaitForCompleteAsync(), pool.WaitForTimeout());

                return(pool.GetResult());
            }
            else
            {
                // request base
                using var pool = new TaskWorkerPool <LongRunBenchmarkData>(_config.ClientConcurrency, ct)
                      {
                          CompleteCondition = x => x.completed >= requestCount,
                      };
                pool.RunWorkers((id, data, ct) => GetClient(id).Process(data), data, ct);
                await Task.WhenAny(pool.WaitForCompleteAsync(), pool.WaitForTimeout());

                return(pool.GetResult());
            }
        }
Esempio n. 2
0
        private async Task <CallResult[]> PlainTextAsync(int requestCount, CancellationToken ct)
        {
            var data = new BenchmarkRequest
            {
                Name = _config.GetRequestPayload(),
            };

            var duration = _config.GetDuration();

            if (duration != TimeSpan.Zero)
            {
                // timeout base
                using var cts       = new CancellationTokenSource(duration);
                using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, ct);
                var linkedCt = linkedCts.Token;

                using var pool = new TaskWorkerPool <BenchmarkRequest, BenchmarkReply>(_config.ClientConcurrency, linkedCt);
                pool.RunWorkers((id, data, ct) => GetClient(id).SayHelloAsync(data), data, ct);
                await Task.WhenAny(pool.WaitForCompleteAsync(), pool.WaitForTimeout());

                return(pool.GetResult());
            }
            else
            {
                // request base
                using var pool = new TaskWorkerPool <BenchmarkRequest, BenchmarkReply>(_config.ClientConcurrency, ct)
                      {
                          CompleteCondition = x => x.completed >= requestCount,
                      };
                pool.RunWorkers((id, data, ct) => GetClient(id).SayHelloAsync(data), data, ct);
                await Task.WhenAny(pool.WaitForCompleteAsync(), pool.WaitForTimeout());

                return(pool.GetResult());
            }
        }