public void TestSendFourHandlers_10_000_000() { var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var channel = new DirectChannel(provider); var count1 = new CounterHandler(); var count2 = new CounterHandler(); var count3 = new CounterHandler(); var count4 = new CounterHandler(); channel.Subscribe(count1); channel.Subscribe(count2); channel.Subscribe(count3); channel.Subscribe(count4); var message = new GenericMessage("test"); for (var i = 0; i < 10000000; i++) { channel.Send(message); } Assert.Equal(10000000 / 4, count1.Count); Assert.Equal(10000000 / 4, count2.Count); Assert.Equal(10000000 / 4, count3.Count); Assert.Equal(10000000 / 4, count4.Count); }
public void TestSendTwoHandlers_10_000_000() { /* * INT-3308 - used to run 6.4 million/sec * 1. Skip empty iterators as above 7.2 million/sec * 2. optimize for single handler 6.7 million/sec (small overhead added) * 3. remove LB rwlock from UnicastingDispatcher 7.2 million/sec * 4. Move single handler optimization to dispatcher 7.3 million/sec */ var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var channel = new DirectChannel(provider); var count1 = new CounterHandler(); var count2 = new CounterHandler(); channel.Subscribe(count1); channel.Subscribe(count2); var message = new GenericMessage("test"); for (var i = 0; i < 10000000; i++) { channel.Send(message); } Assert.Equal(5000000, count1.Count); Assert.Equal(5000000, count2.Count); }
public void DirectChannel_Send_10_000_000_TwoHandlers() { var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var channel = new DirectChannel(provider); var count1 = new CounterHandler(); var count2 = new CounterHandler(); channel.Subscribe(count1); channel.Subscribe(count2); var message = new GenericMessage("test"); for (var i = 0; i < 10_000_000; i++) { channel.Send(message); } if (count1.Count != 5000000) { throw new InvalidOperationException("Handler count1 invalid"); } if (count2.Count != 5000000) { throw new InvalidOperationException("Handler count2 invalid"); } }
public void DirectChannel_Send_10_000_000_SingleHandler() { var services = new ServiceCollection(); var config = new ConfigurationBuilder().Build(); services.AddSingleton <IConfiguration>(config); services.AddSingleton <IApplicationContext, GenericApplicationContext>(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var directChannel = new DirectChannel(provider.GetService <IApplicationContext>()); var handler = new CounterHandler(); directChannel.Subscribe(handler); var message = Message.Create("test"); directChannel.Send(message); for (var i = 0; i < 10_000_000; i++) { directChannel.Send(message); } if (handler.Count != 10_000_000 + 1) { throw new InvalidOperationException("Handler count invalid"); } }
public void TestSendOneHandler_10_000_000() { /* * INT-3308 - used to run 12 million/sec * 1. optimize for single handler 20 million/sec * 2. Don't iterate over empty datatypes 23 million/sec * 3. Don't iterate over empty interceptors 31 million/sec * 4. Move single handler optimization to dispatcher 34 million/sec * * 29 million per second with increment counter in the handler */ var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var channel = new DirectChannel(provider); var handler = new CounterHandler(); channel.Subscribe(handler); var message = new GenericMessage("test"); Assert.True(channel.Send(message)); for (var i = 0; i < 10000000; i++) { channel.Send(message); } Assert.Equal(10000001, handler.Count); }
public void DirectChannel_Send_10_000_000_FourHandlers() { var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var channel = new DirectChannel(provider.GetService <IApplicationContext>()); var count1 = new CounterHandler(); var count2 = new CounterHandler(); var count3 = new CounterHandler(); var count4 = new CounterHandler(); channel.Subscribe(count1); channel.Subscribe(count2); channel.Subscribe(count3); channel.Subscribe(count4); var message = Message.Create("test"); for (var i = 0; i < 10_000_000; i++) { channel.Send(message); } if (count1.Count != 10_000_000 / 4) { throw new InvalidOperationException("Handler count1 invalid"); } if (count2.Count != 10_000_000 / 4) { throw new InvalidOperationException("Handler count2 invalid"); } if (count3.Count != 10_000_000 / 4) { throw new InvalidOperationException("Handler count3 invalid"); } if (count4.Count != 10_000_000 / 4) { throw new InvalidOperationException("Handler count4 invalid"); } }
public void testSend() { DirectChannel channel = new DirectChannel(); ThreadNameExtractingTestTarget target = new ThreadNameExtractingTestTarget(); channel.Subscribe(target); StringMessage message = new StringMessage("test"); Assert.IsTrue(channel.Send(message)); Assert.That(target.ThreadName, Is.EqualTo(Thread.CurrentThread.Name)); }
public async Task TestWaitToWriteAsync() { var provider = services.BuildServiceProvider(); var target = new ThreadNameExtractingTestTarget(); var channel = new DirectChannel(provider.GetService <IApplicationContext>()); channel.Subscribe(target); Assert.True(await channel.Writer.WaitToWriteAsync()); channel.Unsubscribe(target); Assert.False(await channel.Writer.WaitToWriteAsync()); }
public async Task TestWaitToWriteAsync() { var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var target = new ThreadNameExtractingTestTarget(); var channel = new DirectChannel(provider); channel.Subscribe(target); Assert.True(await channel.Writer.WaitToWriteAsync()); channel.Unsubscribe(target); Assert.False(await channel.Writer.WaitToWriteAsync()); }
public async Task TestSendAsync() { var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var target = new ThreadNameExtractingTestTarget(); var channel = new DirectChannel(provider); channel.Subscribe(target); var message = new GenericMessage("test"); Assert.True(await channel.SendAsync(message)); }
public async Task TestWriteAsync() { var provider = services.BuildServiceProvider(); var target = new ThreadNameExtractingTestTarget(); var channel = new DirectChannel(provider.GetService <IApplicationContext>()); channel.Subscribe(target); var message = Message.Create("test"); var currentId = Task.CurrentId; var curThreadId = Thread.CurrentThread.ManagedThreadId; await channel.Writer.WriteAsync(message); Assert.Equal(currentId, target.TaskId); Assert.Equal(curThreadId, target.ThreadId); }
public void testSendInSeparateThread() { CountDownLatch latch = new CountDownLatch(1); DirectChannel channel = new DirectChannel(); ThreadNameExtractingTestTarget target = new ThreadNameExtractingTestTarget(latch); channel.Subscribe(target); StringMessage message = new StringMessage("test"); Thread t = new Thread(new ThreadStart(delegate { channel.Send(message); })); t.Name = "test-thread"; t.Start(); latch.Await(new TimeSpan(0, 0, 0, 0, 1000)); Assert.That(target.ThreadName, Is.EqualTo("test-thread")); }
public void TestTryWrite() { var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var target = new ThreadNameExtractingTestTarget(); var channel = new DirectChannel(provider); channel.Subscribe(target); var message = new GenericMessage("test"); var currentId = Task.CurrentId; var curThreadId = Thread.CurrentThread.ManagedThreadId; Assert.True(channel.Writer.TryWrite(message)); Assert.Equal(currentId, target.TaskId); Assert.Equal(curThreadId, target.ThreadId); }
public void TestSendInSeparateThread() { var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var latch = new CountdownEvent(1); var channel = new DirectChannel(provider); var target = new ThreadNameExtractingTestTarget(latch); channel.Subscribe(target); var message = new GenericMessage("test"); var thread = new Thread(() => channel.Send(message)); thread.Name = "test-thread"; thread.Start(); latch.Wait(1000); Assert.Equal("test-thread", target.ThreadName); }
public async Task ValidateExceptionIfSendToErrorChannelFails() { var provider = services.BuildServiceProvider(); var outChannel = new DirectChannel(provider.GetService <IApplicationContext>()); var handler = new ExceptionHandler(); outChannel.Subscribe(handler); var errorChannel = new PublishSubscribeChannel(provider.GetService <IApplicationContext>()); errorChannel.Subscribe(handler); var mps = new TestMessageProducerSupportEndpoint(provider.GetService <IApplicationContext>()); mps.OutputChannel = outChannel; mps.ErrorChannel = errorChannel; await mps.Start(); Assert.Throws <MessageDeliveryException>(() => mps.SendMessage(Message.Create("hello"))); }
public async Task TestSendAsyncOneHandler_10_000_000() { var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var channel = new DirectChannel(provider); var handler = new CounterHandler(); channel.Subscribe(handler); var message = new GenericMessage("test"); Assert.True(await channel.SendAsync(message)); for (var i = 0; i < 10000000; i++) { await channel.SendAsync(message); } Assert.Equal(10000001, handler.Count); }
public async Task DirectChannel_SendAsync_10_000_000_SingleHandler() { var services = new ServiceCollection(); services.AddSingleton <IIntegrationServices, IntegrationServices>(); var provider = services.BuildServiceProvider(); var directChannel = new DirectChannel(provider); var handler = new CounterHandler(); directChannel.Subscribe(handler); var message = new GenericMessage("test"); await directChannel.SendAsync(message); for (var i = 0; i < 10_000_000; i++) { await directChannel.SendAsync(message); } if (handler.Count != 10_000_000 + 1) { throw new InvalidOperationException("Handler count invalid"); } }