public static void Main(string[] args) { var summaries = BenchmarkSwitcher.FromTypes( Assembly.GetExecutingAssembly().GetTypes().Where(t => typeof(AbstractBenchmark).IsAssignableFrom(t) && !t.IsAbstract).ToArray() // new [] { typeof(WDBC.AchievementAllocationBenchmark) } #if DEBUG ).Run(args, new DebugInProcessConfig());
public static void Main(string[] args) { Logger.Log("Started running performance tests."); try { BenchmarkSwitcher.FromTypes(new[] { typeof(AcquireTokenForClientCacheTests), typeof(AcquireTokenForOboCacheTests), typeof(TokenCacheTests), typeof(AcquireTokenNoCacheTests), }).RunAll( #if DEBUG new DebugInProcessConfig() #else DefaultConfig.Instance #endif .WithOptions(ConfigOptions.DisableLogFile) .WithOptions(ConfigOptions.JoinSummary) //.WithOptions(ConfigOptions.DontOverwriteResults) // Uncomment when running manually .AddDiagnoser(MemoryDiagnoser.Default) // https://benchmarkdotnet.org/articles/configs/diagnosers.html //.AddDiagnoser(new EtwProfiler()) // https://adamsitnik.com/ETW-Profiler/ .AddJob( Job.Default .WithId("Job-PerfTests"))); } catch (Exception ex) { Logger.Log("Error running performance tests."); Logger.Log(ex.ToString()); throw; } Logger.Log("Completed running performance tests."); }
public static void Main(string[] args) { BenchmarkSwitcher.FromTypes(new[] { typeof(WriteFormatsBenchmark), typeof(ReadFormatsBenchmark), }).Run(args); }
private static void Main(string[] args) { BenchmarkSwitcher.FromTypes(new[] { typeof(PuzzleBenchmarker), typeof(CsvBenchmarker), typeof(GeneratorBenchmarker) }).Run(args); }
public void Run() { #if BENCHMARK BenchmarkSwitcher.FromTypes(new[] { this.GetType() }).RunAllJoined(_config); #else Console.WriteLine(nameof(Benchmarks) + " are only supported in the benchmark build."); #endif }
static void Main(string[] args) => BenchmarkSwitcher.FromTypes ( GetOpenGenericBenchmarks() .SelectMany(openGeneric => GetViewModels().Select(viewModel => openGeneric.MakeGenericType(viewModel))) .ToArray() ) .Run(args, new BenchmarkConfig());
static void Main(string[] args) => BenchmarkSwitcher.FromTypes(new[] { typeof(TaskFromResultOrCompletedTask), typeof(ReturnTaskOfT), typeof(ValueTaskVsTaskRecommendedScenario), typeof(ReturnAwaitOrReturnTask), } ).Run(args, new BenchmarkConfig());
static void Main(string[] args) { #if DEBUG new XlsxBenchmark().Epplus_QueryFirst_Test(); #else BenchmarkSwitcher.FromTypes(new[] { typeof(XlsxBenchmark) }).Run(args, new Config()); #endif Console.Read(); }
public static void Main(string[] args) { var switcher = BenchmarkSwitcher.FromTypes(new[] { typeof(SerializerBenchmark), typeof(BoolBenchmark) }); switcher.Run(args); }
static void Main(string[] args) { BenchmarkSwitcher.FromTypes(new[] { typeof(Swapping), typeof(Inlining), typeof(FibonacciCalc), typeof(StringFormatting), }).Run(args); }
static void Main() { //JitDump code: //var type = new Assembler().CompileDelegateType<IAsmDelegateVoid>(Enumerable.Empty<Instruction>(), "Testy"); //var benchmarkType = typeof(Asm<>).MakeGenericType(type); //IBenchmark bench = (IBenchmark)Activator.CreateInstance(benchmarkType); //bench.Test(); BenchmarkSwitcher.FromTypes(TestSource.GetBenchmarkTypes(typeof(Asm <>)).ToArray()).RunAllJoined(); }
static void Main(string[] args) { #if !DEBUG BenchmarkSwitcher.FromTypes(new[] { typeof(XlsxBenchmark) }).Run(args, new Config()); #else BenchmarkSwitcher.FromTypes(new[] { typeof(XlsxBenchmark) }).Run(args, new DebugInProcessConfig()); //new TemplateXlsxBenchmark().MiniExcel_Template_Generate_Test(); //new XlsxBenchmark().MiniExcelCreateTest(); #endif Console.Read(); }
static void Main(string[] args) { BenchmarkSwitcher.FromTypes(new[] { typeof(PingMessageBenchmarks), typeof(InvocationMessageBenchmarks), typeof(StreamInvocationMessageBenchmarks), typeof(StreamItemMessageBenchmarks), typeof(CompletionMessageBenchmarks), typeof(CancelInvocationMessageBenchmarks), typeof(CloseMessageBenchmarks) }).Run(args); //var summary = BenchmarkRunner.Run<MessageDescriptorBenchmarks>(); }
public static void Main(string[] args) { var switcher = BenchmarkSwitcher.FromTypes(new[] { typeof(AddGetRemove), typeof(Contains), typeof(AddGetRemove_Cluster), typeof(Contains_Cluster), typeof(HashesBenchmark) }); switcher.Run(args); }
static void Main(string[] args) { ParserBenchmark pb = new ParserBenchmark(); pb.GlobalSetup(); BenchmarkSwitcher.FromTypes(new Type[] { typeof(ParserBenchmark) }) .RunAllJoined(); Console.ReadKey(); }
public static void Main(string[] args) { var types = new Type[] { typeof(SolvingOisBenchmark), typeof(LinearRegression), typeof(InterpolationBenchmark), typeof(MultiLinearRegression), typeof(WritingDoubleVectorVsDouble), typeof(SobolBlockGeneration), }; var switcher = BenchmarkSwitcher.FromTypes(types); switcher.Run(args); }
static void Main(string[] args) { var switcher = BenchmarkSwitcher.FromTypes(new [] { typeof(SerializationBenchmarks), typeof(DeserializationBenchmarks), }); switcher.RunAll(); var benchmarks = new SerializationBenchmarks(); Console.WriteLine("Google Protobuf size: {0} bytes", benchmarks.GoogleProtobuf()); Console.WriteLine("Protobuf.NET size: {0} bytes", benchmarks.ProtobufNet()); Console.WriteLine("Compact Bond: {0} bytes", benchmarks.CompactBond()); Console.WriteLine("Fast Bond: {0} bytes", benchmarks.FastBond()); }
public static void Main(string[] args) { BenchmarkSwitcher.FromTypes(new [] { typeof(BaselineBenchmark), typeof(NoSamplingBenchmark), typeof(DefaultBenchmark) }).RunAllJoined( DefaultConfig.Instance .With( new Job() .With(RunStrategy.Monitoring) .WithLaunchCount(3) .WithWarmupCount(1) .WithIterationTime(TimeInterval.FromSeconds(10)) .WithCustomBuildConfiguration("ReleaseV3") .WithOutlierMode(OutlierMode.DontRemove) ) .With(MemoryDiagnoser.Default) .With(HardwareCounter.TotalCycles) ); }
private static void Main() { BenchmarkSwitcher.FromTypes(new[] { //typeof(DefaultEcs.CreateEntity), typeof(DefaultEcs.EntitySetFilter), //typeof(DefaultEcs.EntitySetEnumeration), //typeof(DefaultEcs.EntitySetWithComponentEnumeration), //typeof(DefaultEcs.System), //typeof(DefaultEcs.Recorder), //typeof(DefaultEcs.Serialization), //typeof(Performance.SingleComponentEntityEnumeration), //typeof(Performance.DoubleComponentEntityEnumeration), //typeof(Message.Publish), }).RunAll(); //BenchmarkSwitcher.FromAssembly(typeof(Program).GetTypeInfo().Assembly).RunAll(); }
public static void Main(string[] args) { var binaryEncoder = new BinaryEncodeBench(); var binaryDecoder = new BinaryDecodeBench(); var arrayEncoder = new ArrayEncodeBench(); var encodedIntArrayMAA = arrayEncoder.ArrayInt32Encode_MAA_1M(); var encodedIntArraySBA = arrayEncoder.ArrayInt32Encode_SBA_1M(); var areEqual = encodedIntArrayMAA.Span.SequenceEqual(encodedIntArraySBA.Span); if (!areEqual) { Console.WriteLine("Int32 array encoding test did not pass!"); return; } var encodedBinaryMAA = binaryEncoder.Bytes_Encode_MAA(); var encodedBinarySBA = binaryEncoder.Bytes_Encode_SBA(); if (!encodedBinaryMAA.Span.SequenceEqual(encodedBinarySBA.Span)) { Console.WriteLine("Binary encoding test did not pass!"); return; } var decodedBinaryMAA = binaryDecoder.Bytes_Decode_SBA(); if (!decodedBinaryMAA.SequenceEqual(AmqpBench.RandomBytes1MB)) { Console.WriteLine("Binary encoding test did not pass!"); return; } BenchmarkSwitcher .FromTypes(new Type[] { typeof(BinaryEncodeBench), typeof(BinaryDecodeBench), typeof(ArrayDecodeBench), typeof(ArrayEncodeBench) }) .Run(args); }
private static void Main(string[] args) { try { BenchmarkSwitcher.FromTypes(new[] { typeof(AABBTreeTest), //typeof(IndexedLinqTest), //todo: because it very slow //typeof(ListTest), //todo: because it very slow //typeof(MultiIndexCollectionTest), //todo: because it very slow typeof(NTSQuadTreeTest), typeof(NTSSTRTreeTest), typeof(RBushNetTest), typeof(RBushTest), typeof(SortedSplitListTest), typeof(UnityOctreeTest) }).RunAllJoined(); } finally { Console.WriteLine("TestEnded. Press any key to continue"); Console.ReadKey(); } }
static void Main(string[] args) { if (args.Length == 0) { var b = new DeflateCorpus(); var info = b.GetData().First(d => d.ToString() == "alice29.txt"); Thread.Sleep(2000); for (var i = 0; i < 10000; i++) { b.Burnside_ByteArray(info); } Thread.Sleep(2000); for (var i = 0; i < 10000; i++) { b.Burnside_Stream(info); } } else { var benchmarkType = args[0] switch { "deflate-synthetic" => typeof(DeflateSynthetic), "deflate-corpus" => typeof(DeflateCorpus), "allocation" => typeof(AllocationBenchmarks) }; BenchmarkSwitcher.FromTypes(new[] { benchmarkType }).Run(((Span <string>)args).Slice(1).ToArray()); } Console.WriteLine("Done"); Console.ReadLine(); } }
static void Main(string[] args) { BenchmarkSwitcher .FromTypes(new[] { typeof(CompressionOverheadBenchmarks) }) .Run(args); }
static void Main(string[] args) { BenchmarkSwitcher.FromTypes(new[] { typeof(Pbkdf2Bench), }).Run(args); }
static void Main() { BenchmarkSwitcher.FromTypes(new[] { typeof(Brainf_ckBenchmark_Short), typeof(Brainf_ckBenchmark_Long) }).RunAllJoined(); }
static void Main(string[] args) => BenchmarkSwitcher.FromTypes(new[] { typeof(Program) }).Run(args);
public static async Task Main(string[] args) { if (args.Length >= 1) { BenchmarkSwitcher.FromTypes(new[] { typeof(Comparison), typeof(LogMessagesCompression), typeof(LogMessagesSerialization) }).Run(args); return; } Logger.Info("Configuring SQL caches..."); MySqlCache.DefaultInstance.Settings.ConnectionString = ConfigurationManager.ConnectionStrings[nameof(MySql)].ConnectionString; PostgreSqlCache.DefaultInstance.Settings.ConnectionString = ConfigurationManager.ConnectionStrings[nameof(PostgreSql)].ConnectionString; SqlServerCache.DefaultInstance.Settings.ConnectionString = ConfigurationManager.ConnectionStrings[nameof(SqlServer)].ConnectionString; OracleCache.DefaultInstance.Settings.CacheSchemaName = "CARAVAN"; OracleCache.DefaultInstance.Settings.CacheEntriesTableName = "CRVN_KVL_ENTRIES"; OracleCache.DefaultInstance.Settings.ConnectionString = ConfigurationManager.ConnectionStrings[nameof(Oracle)].ConnectionString; PersistentCache.DefaultInstance.Settings.CacheFile = Path.GetTempFileName(); Logger.Info("Running vacuum on SQLite persistent cache..."); PersistentCache.DefaultInstance.Vacuum(); Logger.Info("Generating random data tables..."); _tables = GenerateRandomDataTables(); _tableListSize = GetObjectSizeInMB(_tables); Logger.Info($"Table count: {TablesCount}"); Logger.Info($"Row count: {RowCount}"); Logger.Info($"Total table size: {_tableListSize:0.0} MB"); Logger.Info("Generating random log messages..."); _logMessages = LogMessage.GenerateRandomLogMessages(LogMessagesCount); _logMessagesSize = GetObjectSizeInMB(_logMessages); Logger.Info($"Log messages count: {TablesCount}"); Logger.Info($"Total log messages size: {_logMessagesSize:0.0} MB"); var caches = new ICache[] { MemoryCache.DefaultInstance, MySqlCache.DefaultInstance, //OracleCache.DefaultInstance, PostgreSqlCache.DefaultInstance, SqlServerCache.DefaultInstance, PersistentCache.DefaultInstance, VolatileCache.DefaultInstance }; var asyncCaches = caches.Cast <IAsyncCache>().ToArray(); for (var i = 0; i < IterationCount; ++i) { /*** STORE EACH LOG MESSAGE ASYNC ***/ await FullyCleanCachesAsync(); foreach (var asyncCache in asyncCaches) { await StoreEachLogMessageAsync(asyncCache, i); } /*** STORE EACH DATA TABLE ASYNC ***/ await FullyCleanCachesAsync(); foreach (var asyncCache in asyncCaches) { await StoreEachDataTableAsync(asyncCache, i); } /*** STORE AND RETRIEVE EACH DATA TABLE TWO TIMES ASYNC ***/ await FullyCleanCachesAsync(); foreach (var asyncCache in asyncCaches) { await StoreAndRetrieveEachDataTableAsync(asyncCache, i); } /*** STORE EACH DATA TABLE ***/ FullyCleanCaches(); foreach (var cache in caches) { StoreEachDataTable(cache, i); } /*** STORE EACH DATA TABLE TWO TIMES ***/ FullyCleanCaches(); foreach (var cache in caches) { StoreEachDataTableTwoTimes(cache, i); } /*** REMOVE EACH DATA TABLE ***/ FullyCleanCaches(); foreach (var cache in caches) { RemoveEachDataTable(cache, i); } /*** REMOVE EACH DATA TABLE ASYNC ***/ await FullyCleanCachesAsync(); foreach (var asyncCache in asyncCaches) { await RemoveEachDataTableAsync(asyncCache, i); } /*** PEEK EACH DATA TABLE ***/ FullyCleanCaches(); foreach (var cache in caches) { PeekEachDataTable(cache, i); } /*** RETRIEVE EACH DATA TABLE ***/ FullyCleanCaches(); foreach (var cache in caches) { RetrieveEachDataTable(cache, i); } /*** RETRIEVE EACH DATA TABLE ITEM ***/ FullyCleanCaches(); foreach (var cache in caches) { RetrieveEachDataTableItem(cache, i); } /*** RETRIEVE EACH DATA TABLE ASYNC ***/ await FullyCleanCachesAsync(); foreach (var asyncCache in asyncCaches) { await RetrieveEachDataTableAsync(asyncCache, i); } /*** STORE DATA TABLES LIST ***/ FullyCleanCaches(); foreach (var cache in caches) { StoreDataTableList(cache, i); } /*** STORE EACH DATA TABLE TWO TIMES ASYNC ***/ await FullyCleanCachesAsync(); foreach (var asyncCache in asyncCaches) { await StoreEachDataTableTwoTimesAsync(asyncCache, i); } } FullyCleanCaches(); Console.WriteLine(); Console.Write("Press any key to exit..."); Console.Read(); }
static void Main(string[] args) { BenchmarkSwitcher.FromTypes(new[] { typeof(Program) }).RunAll(); Console.ReadKey(); }
static void Main() { BenchmarkSwitcher.FromTypes(Assembly.GetExecutingAssembly().GetTypes() .Where(t => t.IsSubclassOfRawGeneric(typeof(BenchmarkBase <>))).ToArray()).RunAllJoined(); Console.ReadKey(); }