139 lines
4.1 KiB
C#
139 lines
4.1 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using ExampleLib;
|
|
using Messaging.TapetiExample;
|
|
using SimpleInjector;
|
|
using Tapeti;
|
|
using Tapeti.Default;
|
|
using Tapeti.SimpleInjector;
|
|
|
|
namespace _05_SpeedTest
|
|
{
|
|
public class Program
|
|
{
|
|
private const int MessageCount = 20000;
|
|
|
|
// This does not make a massive difference, since internally Tapeti uses a single thread
|
|
// to perform all channel operations as recommended by the RabbitMQ .NET client library.
|
|
private const int ConcurrentTasks = 20;
|
|
|
|
|
|
public static void Main()
|
|
{
|
|
var container = new Container();
|
|
var dependencyResolver = new SimpleInjectorDependencyResolver(container);
|
|
|
|
container.Register<ILogger, ConsoleLogger>();
|
|
|
|
var helper = new ExampleConsoleApp(dependencyResolver);
|
|
helper.Run(MainAsync);
|
|
}
|
|
|
|
|
|
internal static async Task MainAsync(IDependencyResolver dependencyResolver, Func<Task> waitForDone)
|
|
{
|
|
var container = (IDependencyContainer)dependencyResolver;
|
|
container.RegisterDefaultSingleton<IMessageCounter>(new MessageCounter(MessageCount, () =>
|
|
{
|
|
var exampleState = dependencyResolver.Resolve<IExampleState>();
|
|
exampleState.Done();
|
|
}));
|
|
|
|
|
|
|
|
var config = new TapetiConfig(dependencyResolver)
|
|
// On a developer test machine, this makes the difference between 2200 messages/sec and 3000 messages/sec published.
|
|
// Interesting, but only if speed is more important than guaranteed delivery.
|
|
//.DisablePublisherConfirms()
|
|
.RegisterAllControllers()
|
|
.Build();
|
|
|
|
|
|
await using var connection = new TapetiConnection(config);
|
|
var subscriber = await connection.Subscribe(false);
|
|
|
|
|
|
var publisher = dependencyResolver.Resolve<IPublisher>();
|
|
Console.WriteLine($"Publishing {MessageCount} messages...");
|
|
|
|
var stopwatch = new Stopwatch();
|
|
stopwatch.Start();
|
|
|
|
await PublishMessages(publisher);
|
|
|
|
stopwatch.Stop();
|
|
Console.WriteLine($"Took {stopwatch.ElapsedMilliseconds} ms, {MessageCount / (stopwatch.ElapsedMilliseconds / 1000F):F0} messages/sec");
|
|
|
|
|
|
|
|
Console.WriteLine("Consuming messages...");
|
|
await subscriber.Resume();
|
|
|
|
stopwatch.Restart();
|
|
|
|
await waitForDone();
|
|
|
|
stopwatch.Stop();
|
|
Console.WriteLine($"Took {stopwatch.ElapsedMilliseconds} ms, {MessageCount / (stopwatch.ElapsedMilliseconds / 1000F):F0} messages/sec");
|
|
}
|
|
|
|
|
|
internal static async Task PublishMessages(IPublisher publisher)
|
|
{
|
|
var semaphore = new SemaphoreSlim(ConcurrentTasks);
|
|
var tasks = new List<Task>();
|
|
|
|
for (var i = 0; i < MessageCount; i++)
|
|
{
|
|
var item = i;
|
|
var task = Task.Run(async () =>
|
|
{
|
|
try
|
|
{
|
|
await semaphore.WaitAsync();
|
|
await publisher.Publish(new SpeedTestMessage
|
|
{
|
|
PublishCount = item
|
|
});
|
|
}
|
|
finally
|
|
{
|
|
semaphore.Release();
|
|
}
|
|
});
|
|
|
|
tasks.Add(task);
|
|
}
|
|
|
|
await Task.WhenAll(tasks);
|
|
}
|
|
}
|
|
|
|
|
|
internal class MessageCounter : IMessageCounter
|
|
{
|
|
private readonly int max;
|
|
private readonly Action done;
|
|
private int count;
|
|
|
|
|
|
public MessageCounter(int max, Action done)
|
|
{
|
|
this.max = max;
|
|
this.done = done;
|
|
}
|
|
|
|
|
|
public void Add()
|
|
{
|
|
// With a prefetchcount > 1 the consumers are running in multiple threads,
|
|
// beware of this when using singletons.
|
|
if (Interlocked.Increment(ref count) == max)
|
|
done();
|
|
}
|
|
}
|
|
}
|