private static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[]
{
////typeof(TypelessSerializeBenchmark),
////typeof(TypelessDeserializeBenchmark),
typeof(DeserializeBenchmark),
typeof(SerializeBenchmark),
typeof(DictionaryLookupCompare),
typeof(StringKeyDeserializeCompare),
typeof(NewVsOld),
typeof(GuidImprov),
typeof(ImproveStringKeySerializeBenchmark),
typeof(MessagePackReaderBenchmark),
typeof(MessagePackWriterBenchmark),
typeof(SpanBenchmarks),
typeof(Lz4Benchmark),
typeof(Lz4PrimitiveBenchmark),
});
// args = new[] { "0" };
#if !DEBUG
switcher.Run(args);
#else
switcher.Run(args, new DebugInProcessConfig());
#endif
}
static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[] {
typeof(FirstOrDefaultTypeBench),
typeof(RelationBench),
typeof(IsEvenBench),
typeof(IteratorBench),
typeof(PaginateBench),
typeof(BinarySplitBench),
typeof(TernarySplitBench),
typeof(ListBench),
typeof(FactorialBench),
typeof(FibonacciBench),
typeof(ToArrayVsToListBench),
typeof(AggregateManyBench),
typeof(PowerOfTwoBench),
typeof(RangeDiffBench),
typeof(InvalidateCollectionBench),
typeof(JaggedVsRectArrayBench),
typeof(DictionaryVsLookupBench),
typeof(DoubleEnumerationBench),
typeof(PullOutBench),
typeof(ExceptBench),
typeof(JoinBench),
typeof(AggregateBench),
typeof(EnumerableCreateBench),
typeof(MemberAccessBench)
});
switcher.Run();
Console.ReadLine();
}
// Run it with args = { "*" } for choosing all of target benchmarks
private static void Main(string[] args)
{
var competitionSwitch = new BenchmarkSwitcher(new[]
{
typeof(BclTests.DateTimeBenchmarks),
typeof(BclTests.DateTimeOffsetBenchmarks),
typeof(BclTests.TimeZoneInfoBenchmarks),
typeof(BclTests.UtcDateTimeBenchmarks),
typeof(NodaTimeTests.Calendars.HebrewCalendarBenchmarks),
typeof(NodaTimeTests.Calendars.IsoCalendarBenchmarks),
typeof(NodaTimeTests.JsonNet.FormattingBenchmarks),
typeof(NodaTimeTests.JsonNet.ParsingBenchmarks),
typeof(NodaTimeTests.Text.InstantPatternBenchmarks),
typeof(NodaTimeTests.Text.LocalDatePatternBenchmarks),
typeof(NodaTimeTests.Text.LocalDateTimePatternBenchmarks),
typeof(NodaTimeTests.Text.OffsetDateTimePatternBenchmarks),
typeof(NodaTimeTests.Text.PeriodPatternBenchmarks),
typeof(NodaTimeTests.Text.ZonedDateTimePatternBenchmarks),
typeof(NodaTimeTests.BclDateTimeZoneBenchmarks),
typeof(NodaTimeTests.CachedDateTimeZoneBenchmarks),
typeof(NodaTimeTests.DurationBenchmarks),
typeof(NodaTimeTests.InstantBenchmarks),
typeof(NodaTimeTests.LocalDateBenchmarks),
typeof(NodaTimeTests.LocalDateTimeBenchmarks),
typeof(NodaTimeTests.LocalTimeBenchmarks),
typeof(NodaTimeTests.OffsetBenchmarks),
typeof(NodaTimeTests.OffsetDateTimeBenchmarks),
typeof(NodaTimeTests.PacificZonedDateTimeBenchmarks),
typeof(NodaTimeTests.PeriodBenchmarks),
typeof(NodaTimeTests.StandardDaylightAlternatingMapBenchmarks),
typeof(NodaTimeTests.UtcZonedDateTimeBenchmarks)
});
competitionSwitch.Run(args);
}
public static void Main(string[] args)
{
var switcher =
new BenchmarkSwitcher(
new[]
{
typeof(DictionaryVsIDictionaryBenchmark),
typeof(ListVsIEnumerableBenchmark),
typeof(StringFormatBenchmark),
typeof(RedundantTypeSpecificationBenchmark),
typeof(StringAllocations),
typeof(SimpleExtensionMethods),
typeof(StringInterningBenchmark),
typeof(StringInterningTrickBenchmark),
typeof(StringSplitBenchmark),
typeof(LinqWhereBenchmark),
typeof(SimpleStringFormattingBenchmark),
typeof(StringFormatterBenchmark),
typeof(MethodInvocationOverheadBenchmark),
typeof(UniValueGetValueBenchmark),
typeof(MethodGroupExpressionBenchmark),
typeof(CostOfIsSubclassOfBenchmark),
typeof(StringEmptyBenchmark),
typeof(InliningWithThrowBenchmark),
typeof(HashSetVsUnsafeArrayLookupBenchmark),
typeof(InstructionLevelParallelism),
typeof(IsPrimeBenchmark),
typeof(LoopVariableBenchmark),
typeof(FalseSharingBenchmark)
});
switcher.Run(args);
}
static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[]
{
typeof(MapBenchmark),
});
args = new string[] { "0" };
#if DEBUG
var _foo = Foo.New();
var hee = StandardResolver.Default.GetMapper <Foo, Foo>().Map(_foo, StandardResolver.Default);
var heee = _foo.Adapt <Foo>();
var foo2 = new List <int>()
{
1, 10, 100
};
var foo3 = ObjectMapper.DeepCopy(foo2);
Console.WriteLine(foo3);
#else
switcher.Run(args);
#endif
}
public static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(Benchmarks);
switcher.Run(args);
//switcher.Run(args, FastConfig);
}
static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[]
{
typeof(AssemblyVsDynamicMethod),
typeof(SerializeCheck),
typeof(DeserializeCheck),
typeof(DoubleConvertBenchmark),
typeof(StringToDoubleBenchmark),
typeof(SwitchVsIf),
typeof(SwitchVsSwitch),
});
//args = new string[] { "0" };
#if DEBUG
// {"Name":"foo"}
JsonSerializer.ToJsonString(new MyPerson {
Name = "foo", Addresses = new string[0]
});
// {"Name":"bar","Addresses":["tokyo","kyoto"]}
JsonSerializer.ToJsonString(new MyPerson {
Name = "bar", Addresses = new[] { "tokyo", "kyoto" }
});
#else
switcher.Run(args);
#endif
}
static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[]
{
typeof(AssemblyVsDynamicMethod),
typeof(SerializeCheck),
typeof(DeserializeCheck),
typeof(DoubleConvertBenchmark),
typeof(StringToDoubleBenchmark),
typeof(SwitchVsIf),
typeof(SwitchVsSwitch),
});
//args = new string[] { "0" };
#if DEBUG
//var p = new Person { Age = 99, Name = "foobar" };
//// Object -> byte[] (UTF8)
//byte[] result = JsonSerializer.Serialize(p);
//// byte[] -> Object
//var p2 = JsonSerializer.Deserialize<Person>(result);
//// Object -> byte[]
//var json = JsonSerializer.ToJsonString(p2);
//// Write to Stream
//JsonSerializer.Serialize(stream, p2);
#else
switcher.Run(args);
#endif
}
static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[] {
typeof(GenerationOperationsBenchmarks),
typeof(EmptyBenchmarks),
typeof(CountBenchmarks),
typeof(CountPredicateBenchmarks),
typeof(AllBenchmarks),
typeof(AnyBenchmarks),
typeof(AnyPredicateBenchmarks),
typeof(ContainsBenchmarks),
typeof(FirstBenchmarks),
typeof(FirstOrDefaultBenchmarks),
typeof(SingleBenchmarks),
typeof(SingleOrDefaultBenchmarks),
typeof(ToArrayBenchmarks),
typeof(ToListBenchmarks),
typeof(SelectBenchmarks),
typeof(SelectCountBenchmarks),
typeof(SelectToArrayBenchmarks),
typeof(SelectToListBenchmarks),
typeof(WhereBenchmarks),
typeof(WhereCountBenchmarks),
typeof(WhereFirstBenchmarks),
typeof(WhereFirstOrDefaultBenchmarks),
typeof(WhereSingleBenchmarks),
typeof(WhereSingleOrDefaultBenchmarks),
typeof(WhereToArrayBenchmarks),
typeof(WhereToListBenchmarks),
typeof(WhereSelectBenchmarks),
typeof(WhereSelectCountBenchmarks),
});
switcher.Run(args);
}
static void Main(string[] args)
{
var assembly = System.Reflection.Assembly.GetExecutingAssembly();
var switcher = new BenchmarkSwitcher(assembly);
switcher.Run(args);
}
private static void Main()
{
Console.WriteLine("Effective Rx-version: " + typeof(Observable).Assembly.GetName().Version);
var switcher = new BenchmarkSwitcher(new[] {
typeof(ZipBenchmark),
typeof(CombineLatestBenchmark),
typeof(SwitchBenchmark),
typeof(BufferCountBenchmark),
typeof(RangeBenchmark),
typeof(ToObservableBenchmark),
typeof(RepeatBenchmark),
typeof(ComparisonBenchmark),
typeof(ComparisonAsyncBenchmark),
typeof(ScalarScheduleBenchmark),
typeof(StableCompositeDisposableBenchmark),
typeof(SubjectBenchmark),
typeof(ComparisonAsyncBenchmark)
#if (CURRENT)
,typeof(AppendPrependBenchmark)
#endif
});
switcher.Run();
Console.ReadLine();
}
static void Main(string[] args)
{
if (args.Length > 0 && args[0] == "loop")
{
var benchmarks = new ComplexTypeBenchmarks();
while (true)
{
benchmarks.SerializeComplex();
}
}
if (args.Length > 0 && args[0] == "structloop")
{
var benchmarks = new ComplexTypeBenchmarks();
while (true)
{
benchmarks.SerializeStruct();
}
}
var switcher = new BenchmarkSwitcher(new[]
{
typeof(DeserializeBenchmark),
typeof(SerializeBenchmark),
typeof(StructSerializeBenchmark),
typeof(StructDeserializeBenchmark),
typeof(ComplexTypeBenchmarks)
});
switcher.Run(args);
}
public static void Main(string[] args)
{
var types = typeof(Program)
.Assembly
.GetExportedTypes()
.Where(r => r != typeof(Program) && r.IsPublic)
.OrderBy(r => r.Name);
var job = Job.Default;
var config = new ManualConfig();
config.AddLogger(DefaultConfig.Instance.GetLoggers().ToArray());
config.AddExporter(DefaultConfig.Instance.GetExporters().ToArray());
config.AddColumnProvider(DefaultConfig.Instance.GetColumnProviders().ToArray());
config.AddValidator(JitOptimizationsValidator.DontFailOnError);
//config.AddJob(job.WithRuntime(ClrRuntime.Net461));
//config.AddJob(job.WithRuntime(CoreRuntime.Core21));
//config.AddJob(job.WithRuntime(CoreRuntime.Core31));
config.AddJob(job.WithRuntime(CoreRuntime.Core50));
config.AddDiagnoser(MemoryDiagnoser.Default);
config.AddColumn(StatisticColumn.OperationsPerSecond);
config.AddColumn(RankColumn.Arabic);
var switcher = new BenchmarkSwitcher(types.ToArray());
switcher.Run(args, config);
}
static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(typeof(Program).Assembly);
var config = GetConfig(args);
switcher.Run(new[] { "--filter", "*" }, config);
}
private static IEnumerable <Summary> RunAll()
{
var switcher = new BenchmarkSwitcher(typeof(Program).Assembly);
var summaries = switcher.Run(new[] { "*" });
return(summaries);
}
public static void Main(string[] args)
{
var types = Benchmarks.FindBenchmarks();
var switcher = new BenchmarkSwitcher(types);
switcher.Run(args);
}
private static IEnumerable <Summary> RunAll(IConfig config, string[] args)
{
var switcher = new BenchmarkSwitcher(typeof(Program).Assembly);
var summaries = switcher.Run(args, config);
return(summaries);
}
private static void Main(string[] args)
{
// dotnet run -c Release -- --methods=ReadUtf8Char
var switcher = new BenchmarkSwitcher(typeof(Program).Assembly);
switcher.Run(args);
}
public int OnExecute()
{
try
{
using (var dynamicContext = new AssemblyResolver(Path.GetFullPath(AssemblyFile)))
{
BenchmarkSwitcher benchmarkSwitcher = BenchmarkSwitcher.FromAssembly(dynamicContext.Assembly);
benchmarkSwitcher.Run(RemainingArguments);
}
}
catch (FileLoadException ex)
{
Console.Error.WriteLine($"Couldn't load the assembly {AssemblyFile}.");
Console.Error.WriteLine(ex.ToString());
return(1);
}
catch (BadImageFormatException ex)
{
Console.Error.WriteLine($"The assembly {AssemblyFile} is not a valid assembly.");
Console.Error.WriteLine(ex.ToString());
return(1);
}
return(0);
}
private static void Main()
{
var benchmarksAssembly = typeof(Program).GetTypeInfo().Assembly;
var benchmarkSwitcher = new BenchmarkSwitcher(benchmarksAssembly);
benchmarkSwitcher.Run();
}
public static void Main(string[] args)
{
Console.WriteLine("Initiating benchmarking");
var config = ManualConfig
.Create(DefaultConfig.Instance);
// ensure numbers in csv do not have units
var csvExporter = new CsvExporter(
CsvSeparator.CurrentCulture,
new SummaryStyle()
{
PrintUnitsInHeader = true,
PrintUnitsInContent = false,
TimeUnit = BenchmarkDotNet.Horology.TimeUnit.Millisecond,
});
config.Add(csvExporter);
// I experimented with removing outliers but I think other processes on the system create outliers more
// than abnormal data access patterns
config.Add(
Job.Default.WithRemoveOutliers(true));
var switcher = new BenchmarkSwitcher(new[] { typeof(GetFileBenchmark), typeof(FileExistsBenchmark) });
var summary = switcher.Run(args, config);
Console.WriteLine("Benchmarking complete");
}
public static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[] {
typeof(AllTheThingsBenchmarks),
});
switcher.Run(args);
}
static void Main(string[] args)
{
BenchmarkSwitcher switcher = new BenchmarkSwitcher(new[] {
typeof(FsContainerBenchmark)
});
switcher.Run();
}
static void Main(string[] args)
{
BenchmarkSwitcher switcher = new BenchmarkSwitcher(Assembly.GetCallingAssembly());
switcher.Run(args);
Console.ReadLine();
}
static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[] {
typeof(QueryBenchmarks),
});
switcher.Run(args);
}
public static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[] {
typeof(UrlPathToUrlPathTemplateMatcherBenchmarks),
});
switcher.Run(args);
}
static void Main(string[] args)
{
var competition = new BenchmarkSwitcher(new[] {
typeof(CircularBufferBenchmarks),
});
competition.Run(args);
}
static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(new[] {
typeof(PresentationPropertyBenchmark),
});
switcher.Run(args);
}
static void Main(string[] args)
{
var benchmarks =
typeof(Program).GetTypeInfo().Assembly.ExportedTypes.Where(t => !t.GetTypeInfo().IsAbstract&& t.Name.EndsWith("Benchmark"));
var switcher = new BenchmarkSwitcher(benchmarks.ToArray());
switcher.Run(args, new BenchmarkConfig());
}
private static void Main(string[] args)
{
var switcher = new BenchmarkSwitcher(typeof(BenchmarkConfig).Assembly);
//switcher.RunAll(new BenchmarkConfigWitRows());
//For single run.
switcher.Run(args, new BenchmarkConfigWitRows());
}
static void Main(string[] args)
{
// Use reflection for a more maintainable way of creating the benchmark switcher,
// Benchmarks are listed in namespace order first (e.g. BenchmarkDotNet.Samples.CPU,
// BenchmarkDotNet.Samples.IL, etc) then by name, so the output is easy to understand
var benchmarks = Assembly.GetExecutingAssembly().GetTypes()
.Where(t => t.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Any(m => m.GetCustomAttributes(typeof(BenchmarkAttribute), false).Any()))
.OrderBy(t => t.Namespace)
.ThenBy(t => t.Name)
.ToArray();
var competitionSwitch = new BenchmarkSwitcher(benchmarks);
competitionSwitch.Run(args);
}
