static RecyclablePooledFactoriesAndChannelsAsync_OpenOnce() { s_test = new TestTemplate(); // It is expected to see various exceptions when we use factories while recycling them (s_test as IExceptionPolicy).RelaxedExceptionPolicy = true; s_recyclablePooledFactoriesAndChannels = StaticDisposablesHelper.AddDisposable( new PoolOfAsyncThings < FactoryAndPoolOfItsAsyncObjects <ChannelFactory <ChannelType>, OpenAsyncOnceChannelWrapper <ChannelType> > >( maxSize: s_test.TestParameters.MaxPooledFactories, createInstance: () => new FactoryAndPoolOfItsAsyncObjects <ChannelFactory <ChannelType>, OpenAsyncOnceChannelWrapper <ChannelType> >( createFactoryInstance: s_test.CreateChannelFactory, destroyFactoryInstanceAsync: async(chf) => await s_test.CloseFactoryAsync(chf), maxPooledObjects: s_test.TestParameters.MaxPooledChannels, createObject: (chf) => { var channel = s_test.CreateChannel(chf); // If channel creation failed and is unexpected we'd already catch it inside s_test.CreateChannel. // If the failure is expected then we will get null back. // In this case we simply return null instead of wrapping it and let the pool handle it return(channel != null ? new OpenAsyncOnceChannelWrapper <ChannelType>(channel) : null); }, destroyObjectAsync: async(chWr) => await s_test.CloseChannelAsync(chWr.Channel), validateObjectInstance: (oaocw) => s_test.ValidateChannel(oaocw.Channel)), destroyInstanceAsync: async(fapoio) => await fapoio.DestroyAsync(), instanceValidator: (fapoio) => s_test.ValidateFactory(fapoio.Factory))); }
private static void DoTheRun(int iterations) { Console.WriteLine("Start"); Task[] allTasks = new Task[13]; for (int t = 0; t < allTasks.Length; t++) { int tt = t; allTasks[t] = Task.Run(() => { var ttt = tt; for (int i = 0; i < iterations; i++) { try { //RunAllHttpStressTests(); // for TestHelpers.SetHostAndProtocol(useHttp: true RunAllNetTcpStressTests(); // for TestHelpers.SetHostAndProtocol(useHttp: false } catch (Exception e) { System.Diagnostics.Debugger.Break(); } if (i % 1000 == 0) { Console.WriteLine(ttt + " " + i); } } Console.WriteLine(ttt + ": done"); }); } Task.WaitAll(allTasks); Console.WriteLine("Dispose all"); StaticDisposablesHelper.DisposeAll(); }
static RecyclablePooledFactoriesAndChannels_OpenOnce() { // moving the following magic numbers to the test template interface will help each test to collect different type of stats s_CreateChannelStats = new CallStats(samples: 1000, errorSamples: 1000); s_CallChannelStats = new CallStats(samples: 1000000, errorSamples: 10000); s_CloseChannelStats = new CallStats(samples: 1000, errorSamples: 1000); s_CloseFactoryStats = new CallStats(samples: 1000, errorSamples: 1000); s_test = new TestTemplate(); Console.WriteLine(s_test.GetType().ToString()); // Perhaps a helper (extension?) method to hide new PoolOfThings would make things more readable s_recyclablePooledFactoriesAndChannels = StaticDisposablesHelper.AddDisposable( new PoolOfThings <FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, OpenOnceChannelWrapper <ChannelType> > >( maxSize: 3, // # of pooled FactoryAndPoolOfItsObjects createInstance: () => new FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, OpenOnceChannelWrapper <ChannelType> >( createFactoryInstance: () => s_test.CreateChannelFactory(), destroyFactoryInstance: (chf) => s_CloseFactoryStats.CallActionAndRecordStats(() => s_test.CloseFactory(chf)), maxPooledObjects: 3, // # of pooled channels within each pooled FactoryAndPoolOfItsObjects createObject: (chf) => s_CreateChannelStats.CallFuncAndRecordStats(func: () => new OpenOnceChannelWrapper <ChannelType>(s_test.CreateChannel(chf))), destroyObject: (chWr) => s_CloseChannelStats.CallActionAndRecordStats(action: () => s_test.CloseChannel(chWr.Channel)) ), destroyInstance: (_fapoic) => _fapoic.Destroy())); }
static PooledFactoriesAsync() { s_test = new TestTemplate(); s_pooledChannelFactories = StaticDisposablesHelper.AddDisposable( new PoolOfAsyncThings <ChannelFactory <ChannelType> >( maxSize: s_test.TestParameters.MaxPooledFactories, createInstance: () => s_test.CreateChannelFactory(), destroyInstanceAsync: async(chf) => await s_test.CloseFactoryAsync(chf))); }
static PooledFactories() { s_test = new TestTemplate(); s_pooledChannelFactories = StaticDisposablesHelper.AddDisposable( new PoolOfThings <ChannelFactory <ChannelType> >( maxSize: s_test.TestParameters.MaxPooledFactories, createInstance: () => s_test.CreateChannelFactory(), destroyInstance: (chf) => s_test.CloseFactory(chf), instanceValidator: s_test.ValidateFactory)); }
static PooledFactories() { s_test = new TestTemplate(); s_pooledChannelFactories = StaticDisposablesHelper.AddDisposable( new PoolOfThings <ChannelFactory <ChannelType> >( maxSize: 10, createInstance: () => s_test.CreateChannelFactory(), destroyInstance: (chf) => s_CloseFactoryStats.CallActionAndRecordStats(() => s_test.CloseFactory(chf)))); }
static RecyclablePooledFactoriesAsync() { s_test = new TestTemplate(); // It is expected to see various exceptions when we use factories while recycling them (s_test as IExceptionPolicy).RelaxedExceptionPolicy = true; s_recyclablePooledChannelFactories = StaticDisposablesHelper.AddDisposable( new PoolOfAsyncThings <ChannelFactory <ChannelType> >( maxSize: s_test.TestParameters.MaxPooledFactories, createInstance: s_test.CreateChannelFactory, destroyInstanceAsync: async(chf) => await s_test.CloseFactoryAsync(chf))); }
static PooledFactoriesAsync() { s_test = new TestTemplate(); // we do not expect exceptions here since we're not closing anything during usage (s_test as IExceptionPolicy).RelaxedExceptionPolicy = false; s_pooledChannelFactories = StaticDisposablesHelper.AddDisposable( new PoolOfAsyncThings <ChannelFactory <ChannelType> >( maxSize: s_test.TestParameters.MaxPooledFactories, createInstance: () => s_test.CreateChannelFactory(), destroyInstanceAsync: async(chf) => await s_test.CloseFactoryAsync(chf), instanceValidator: s_test.ValidateFactory)); }
private void DoTheRunAsync(Func <Task> testAsync) { var cts = new CancellationTokenSource(_paramStressRunDuration); Console.WriteLine("Start"); Task[] allTasks = new Task[_paramStressLevel]; for (int t = 0; t < allTasks.Length; t++) { int tt = t; allTasks[t] = Task.Run(async() => { var ttt = tt; for (long i = 0; i < _paramIterations / allTasks.Length; i++) { try { await testAsync(); } catch (ObjectDisposedException e) { TestUtils.ReportFailure(e.ToString()); } catch (Exception e) { TestUtils.ReportFailure(e.ToString()); throw; } if (i % 100 == 0) { Console.WriteLine(DateTime.Now.ToString() + " " + ttt + " " + i); } if (cts.Token.IsCancellationRequested) { break; } } Console.WriteLine(ttt + ": done"); }, cts.Token); } Task.WaitAll(allTasks); Console.WriteLine("Dispose all"); StaticDisposablesHelper.DisposeAll(); }
static RecyclablePooledFactoriesAndChannels_OpenOnce() { s_test = new TestTemplate(); // It is expected to see various exceptions when we use factories while recycling them (s_test as IExceptionPolicy).RelaxedExceptionPolicy = true; s_recyclablePooledFactoriesAndChannels = StaticDisposablesHelper.AddDisposable( new PoolOfThings <FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, OpenOnceChannelWrapper <ChannelType> > >( maxSize: s_test.TestParameters.MaxPooledFactories, createInstance: () => new FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, OpenOnceChannelWrapper <ChannelType> >( createFactoryInstance: () => s_test.CreateChannelFactory(), destroyFactoryInstance: (chf) => s_test.CloseFactory(chf), maxPooledObjects: s_test.TestParameters.MaxPooledChannels, createObject: (chf) => new OpenOnceChannelWrapper <ChannelType>(s_test.CreateChannel(chf)), destroyObject: (chWr) => s_test.CloseChannel(chWr.Channel)), destroyInstance: (_fapoio) => _fapoio.Destroy())); }
static PooledFactoriesAndChannelsAsync() { s_test = new TestTemplate(); s_pooledFactoriesAndChannels = StaticDisposablesHelper.AddDisposable( new PoolOfAsyncThings <FactoryAndPoolOfItsAsyncObjects <ChannelFactory <ChannelType>, ChannelType> >( maxSize: s_test.TestParameters.MaxPooledFactories, // # of pooled FactoryAndPoolOfItsObjects createInstance: () => new FactoryAndPoolOfItsAsyncObjects <ChannelFactory <ChannelType>, ChannelType>( createFactoryInstance: s_test.CreateChannelFactory, destroyFactoryInstanceAsync: async(chf) => await s_test.CloseFactoryAsync(chf), maxPooledObjects: s_test.TestParameters.MaxPooledChannels, // # of pooled channels within each pooled FactoryAndPoolOfItsObjects createObject: (chf) => s_test.CreateChannel(chf), destroyObjectAsync: async(ch) => await s_test.CloseChannelAsync(ch) ), destroyInstanceAsync: async(_fapoiao) => await _fapoiao.DestroyAsync())); }
static PooledFactoriesAndChannels() { s_test = new TestTemplate(); s_pooledFactoriesAndChannels = StaticDisposablesHelper.AddDisposable( new PoolOfThings <FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, ChannelType> >( maxSize: 3, // # of pooled FactoryAndPoolOfItsObjects createInstance: () => new FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, ChannelType>( createFactoryInstance: s_test.CreateChannelFactory, destroyFactoryInstance: (chf) => s_CloseFactoryStats.CallActionAndRecordStats(() => s_test.CloseFactory(chf)), maxPooledObjects: 3, // # of pooled channels within each pooled FactoryAndPoolOfItsObjects createObject: (chf) => s_CreateChannelStats.CallFuncAndRecordStats(s_test.CreateChannel, chf), destroyObject: (ch) => s_CloseChannelStats.CallActionAndRecordStats(() => s_test.CloseChannel(ch)) ), destroyInstance: (_fapoic) => _fapoic.Destroy())); }
static PooledFactoriesAndChannels() { s_test = new TestTemplate(); s_pooledFactoriesAndChannels = StaticDisposablesHelper.AddDisposable( new PoolOfThings <FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, ChannelType> >( maxSize: s_test.TestParameters.MaxPooledFactories, // # of pooled FactoryAndPoolOfItsObjects createInstance: () => new FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, ChannelType>( createFactoryInstance: s_test.CreateChannelFactory, destroyFactoryInstance: (chf) => s_test.CloseFactory(chf), maxPooledObjects: s_test.TestParameters.MaxPooledChannels, // # of pooled channels within each pooled FactoryAndPoolOfItsObjects createObject: (chf) => s_test.CreateChannel(chf), destroyObject: (ch) => s_test.CloseChannel(ch), validateObjectInstance: s_test.ValidateChannel), destroyInstance: (fapoio) => fapoio.Destroy(), instanceValidator: (fapoiao) => s_test.ValidateFactory(fapoiao.Factory))); }
static RecyclablePooledFactoriesAndChannelsAsync() { s_test = new TestTemplate(); // It is expected to see various exceptions when we use factories while recycling them (s_test as IExceptionPolicy).RelaxedExceptionPolicy = true; s_recyclablePooledFactoriesAndChannels = StaticDisposablesHelper.AddDisposable( new PoolOfAsyncThings <FactoryAndPoolOfItsAsyncObjects <ChannelFactory <ChannelType>, ChannelType> >( maxSize: s_test.TestParameters.MaxPooledFactories, createInstance: () => new FactoryAndPoolOfItsAsyncObjects <ChannelFactory <ChannelType>, ChannelType>( createFactoryInstance: () => s_test.CreateChannelFactory(), destroyFactoryInstanceAsync: async(chf) => await s_test.CloseFactoryAsync(chf), maxPooledObjects: s_test.TestParameters.MaxPooledChannels, createObject: (chf) => s_test.CreateChannel(chf), destroyObjectAsync: (ch) => s_test.CloseChannelAsync(ch), validateObjectInstance: s_test.ValidateChannel), destroyInstanceAsync: (fapoio) => fapoio.DestroyAsync(), instanceValidator: (fapoio) => s_test.ValidateFactory(fapoio.Factory))); }
static RecyclablePooledFactoriesAndChannelsAsync_OpenOnce() { s_test = new TestTemplate(); s_recyclablePooledFactoriesAndChannels = StaticDisposablesHelper.AddDisposable( new PoolOfAsyncThings < FactoryAndPoolOfItsAsyncObjects <ChannelFactory <ChannelType>, OpenAsyncOnceChannelWrapper <ChannelType> > >( maxSize: 3, // # of pooled FactoryAndPoolOfItsChannels createInstance: () => new FactoryAndPoolOfItsAsyncObjects <ChannelFactory <ChannelType>, OpenAsyncOnceChannelWrapper <ChannelType> >( createFactoryInstance: s_test.CreateChannelFactory, destroyFactoryInstanceAsync: async(chf) => await s_CloseFactoryStats.CallAsyncFuncAndRecordStatsAsync(s_test.CloseFactoryAsync, chf), maxPooledObjects: 3, // # of pooled channels within each pooled FactoryAndPoolOfItsAsyncObjects createObject: (chf) => s_CreateChannelStats.CallFuncAndRecordStats(func: () => new OpenAsyncOnceChannelWrapper <ChannelType>(s_test.CreateChannel(chf))), destroyObjectAsync: async(chWr) => await s_CloseChannelStats.CallAsyncFuncAndRecordStatsAsync(func: () => s_test.CloseChannelAsync(chWr.Channel)) ), destroyInstanceAsync: async(_fapoic) => await _fapoic.DestroyAsync())); }
static PooledFactoriesAndChannels() { s_test = new TestTemplate(); // we do not expect exceptions here since we're not closing anything during usage (s_test as IExceptionPolicy).RelaxedExceptionPolicy = false; s_pooledFactoriesAndChannels = StaticDisposablesHelper.AddDisposable( new PoolOfThings <FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, ChannelType> >( maxSize: s_test.TestParameters.MaxPooledFactories, // # of pooled FactoryAndPoolOfItsObjects createInstance: () => new FactoryAndPoolOfItsObjects <ChannelFactory <ChannelType>, ChannelType>( createFactoryInstance: s_test.CreateChannelFactory, destroyFactoryInstance: (chf) => s_test.CloseFactory(chf), maxPooledObjects: s_test.TestParameters.MaxPooledChannels, // # of pooled channels within each pooled FactoryAndPoolOfItsObjects createObject: (chf) => s_test.CreateChannel(chf), destroyObject: (ch) => s_test.CloseChannel(ch), validateObjectInstance: s_test.ValidateChannel), destroyInstance: (fapoio) => fapoio.Destroy(), instanceValidator: (fapoiao) => s_test.ValidateFactory(fapoiao.Factory))); }
public void RunPerf() { switch (_paramTestToRun) { case "HelloWorld": if (_paramUseAsync) { RunFirstNIterationsAsync(MaxIterations, MaxTasks, testAsync: RunStartupPerfTestsAsync <IService1, HelloWorldTest <CommonPerfStartupTestParams>, CommonPerfStartupTestParams>); RunMaxThroughputAsync(duration: s_measurementDuration, maxTasks: MaxTasks, testAsync: RunThroughputPerfTestsAsync <IService1, HelloWorldTest <CommonPerfThroughputTestParams>, CommonPerfThroughputTestParams>); } else { RunFirstNIterations(MaxIterations, MaxTasks, test: RunStartupPerfTests <IService1, HelloWorldTest <CommonPerfStartupTestParams>, CommonPerfStartupTestParams>); RunMaxThroughput(duration: s_measurementDuration, maxTasks: MaxTasks, test: RunThroughputPerfTests <IService1, HelloWorldTest <CommonPerfThroughputTestParams>, CommonPerfThroughputTestParams>); } break; case "Streaming": if (_paramUseAsync) { RunFirstNIterationsAsync(MaxIterations, MaxTasks, testAsync: RunStartupPerfTestsAsync <IStreamingService, StreamingTest <IStreamingService, StreamingPerfStartupTestParams>, StreamingPerfStartupTestParams>); RunMaxThroughputAsync(duration: s_measurementDuration, maxTasks: MaxTasks, testAsync: RunThroughputPerfTestsAsync <IStreamingService, StreamingTest <IStreamingService, StreamingPerfThroughputTestParams>, StreamingPerfThroughputTestParams>); } else { RunFirstNIterations(MaxIterations, MaxTasks, test: RunStartupPerfTests <IStreamingService, StreamingTest <IStreamingService, StreamingPerfStartupTestParams>, StreamingPerfStartupTestParams>); RunMaxThroughput(duration: s_measurementDuration, maxTasks: MaxTasks, test: RunThroughputPerfTests <IStreamingService, StreamingTest <IStreamingService, StreamingPerfThroughputTestParams>, StreamingPerfThroughputTestParams>); } break; case "Duplex": if (_paramUseAsync) { RunFirstNIterationsAsync(MaxIterations, MaxTasks, testAsync: RunStartupPerfTestsAsync <IDuplexService, DuplexTest <DuplexPerfStartupTestParams>, DuplexPerfStartupTestParams>); RunMaxThroughputAsync(duration: s_measurementDuration, maxTasks: MaxTasks, testAsync: RunThroughputPerfTestsAsync <IDuplexService, DuplexTest <DuplexPerfThroughputTestParams>, DuplexPerfThroughputTestParams>); } else { RunFirstNIterations(MaxIterations, MaxTasks, test: RunStartupPerfTests <IDuplexService, DuplexTest <DuplexPerfStartupTestParams>, DuplexPerfStartupTestParams>); RunMaxThroughput(duration: s_measurementDuration, maxTasks: MaxTasks, test: RunThroughputPerfTests <IDuplexService, DuplexTest <DuplexPerfThroughputTestParams>, DuplexPerfThroughputTestParams>); } break; case "DuplexStreaming": if (_paramUseAsync) { RunFirstNIterationsAsync(MaxIterations, MaxTasks, testAsync: RunStartupPerfTestsAsync <IDuplexStreamingService, DuplexStreamingTest <IDuplexStreamingService, DuplexStreamingPerfStartupTestParams>, DuplexStreamingPerfStartupTestParams>); RunMaxThroughputAsync(duration: s_measurementDuration, maxTasks: MaxTasks, testAsync: RunThroughputPerfTestsAsync <IDuplexStreamingService, DuplexStreamingTest <IDuplexStreamingService, DuplexStreamingPerfThroughputTestParams>, DuplexStreamingPerfThroughputTestParams>); } else { RunFirstNIterations(MaxIterations, MaxTasks, test: RunStartupPerfTests <IDuplexStreamingService, DuplexStreamingTest <IDuplexStreamingService, DuplexStreamingPerfStartupTestParams>, DuplexStreamingPerfStartupTestParams>); RunMaxThroughput(duration: s_measurementDuration, maxTasks: MaxTasks, test: RunThroughputPerfTests <IDuplexStreamingService, DuplexStreamingTest <IDuplexStreamingService, DuplexStreamingPerfThroughputTestParams>, DuplexStreamingPerfThroughputTestParams>); } break; default: Console.WriteLine("wrong argument: " + _paramTestToRun); return; } var sw = new Stopwatch(); sw.Start(); StaticDisposablesHelper.DisposeAll(); Console.WriteLine("Dispose all done in " + sw.ElapsedMilliseconds); }