public BenchResult BenchMark(IBench bench)
{
var warmuprounds = bench.WarmupRounds ?? WarmupRounds;
var iterations = bench.Iterations ?? Iterations;
//Warmup
if (warmuprounds > 0)
{
BenchWarmup(this, new BenchRunningEventArgs {
Title = bench.Title, Iterations = warmuprounds
});
bench.Execute(warmuprounds);
}
// Give the test as good a chance as possible of avoiding garbage collection
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
BenchRunning(this, new BenchRunningEventArgs {
Title = bench.Title, Iterations = iterations
});
var s = Stopwatch.StartNew();
bench.Execute(iterations);
var e = s.Elapsed;
var result = new BenchResult
{
Elapsed = e,
Iterations = iterations
};
BenchComplete(this, new BenchCompleteEventArgs
{
Title = bench.Title,
Result = result
});
return(result);
}
static void Main()
{
var simplerng = new SimpleUlidRng();
var csrng = new CSUlidRng();
var simplemonotonicrng = new MonotonicUlidRng(simplerng);
var csmonotonicrng = new MonotonicUlidRng(csrng);
var plainrng = new Random();
var pt = new SimpleBencher(10000000);
//pt.BenchRunning += (s, e) => Console.WriteLine($"Running {e.Title}, {e.Iterations:N0} iterations...");
//pt.BenchWarmup += (s, e) => Console.WriteLine($"Warmup {e.Title}, {e.Iterations:N0} iterations...");
pt.BenchComplete += (s, e) => Console.WriteLine($"Completed {e.Title,-40}: {e.Result.OperationsPerSecond(),15:N0}/sec.");
var d = DateTimeOffset.Now;
var benchtests = new IBench[] {
new ForBench("Guid.NewGuid()", () => Guid.NewGuid()),
new ForBench("Ulid.NewUlid(SimpleUlidRng)", () => Ulid.NewUlid(simplerng)),
new ForBench("Ulid.NewUlid(CSUlidRng)", () => Ulid.NewUlid(csrng)),
new ForBench("Ulid.NewUlid(SimpleMonotonicUlidRng)", () => Ulid.NewUlid(simplemonotonicrng)),
new ForBench("Ulid.NewUlid(CSMonotonicUlidRng)", () => Ulid.NewUlid(csmonotonicrng)),
new ForEachBench <string>("Guid.Parse(string)", (i) => Guid.Parse(i), (i) => Enumerable.Range(0, i).Select(n => Guid.NewGuid().ToString())),
new ForEachBench <string>("Ulid.Parse(string)", (i) => Ulid.Parse(i), (i) => Enumerable.Range(0, i).Select(n => Ulid.NewUlid().ToString())),
new ForEachBench <Guid>("Guid.ToString()", (i) => i.ToString(), (i) => Enumerable.Range(0, i).Select(n => Guid.NewGuid())),
new ForEachBench <Ulid>("Ulid.ToString()", (i) => i.ToString(), (i) => Enumerable.Range(0, i).Select(n => Ulid.NewUlid())),
new ForEachBench <byte[]>("new Guid(byte[])", (i) => new Guid(i), (i) => Enumerable.Range(0, i).Select(n => { var b = new byte[16]; plainrng.NextBytes(b); return(b); })),
new ForEachBench <byte[]>("new Ulid(byte[])", (i) => new Ulid(i), (i) => Enumerable.Range(0, i).Select(n => { var b = new byte[16]; plainrng.NextBytes(b); return(b); })),
new ForEachBench <Guid>("Guid.ToByteArray()", (i) => i.ToByteArray(), (i) => Enumerable.Range(0, i).Select(n => Guid.NewGuid())),
new ForEachBench <Ulid>("Ulid.ToByteArray()", (i) => i.ToByteArray(), (i) => Enumerable.Range(0, i).Select(n => Ulid.NewUlid())),
new ForEachBench <Ulid>("Ulid.ToGuid()", (i) => i.ToGuid(), (i) => Enumerable.Range(0, i).Select(n => Ulid.NewUlid())),
new ForEachBench <Guid>("new Ulid(Guid)", (i) => new Ulid(i), (i) => Enumerable.Range(0, i).Select(n => Guid.NewGuid())),
};
var results = pt.BenchMark(benchtests).ToArray();
Console.WriteLine("Done.");
}
public static void Main(string[] args)
{
var loopCount = "5";
IBench bench = null;
Thread runnerThread = null;
BenchResult <Object> result = null;
int executionCount = 5;
List <BenchResult <Object> > results = new List <BenchResult <object> >();
if (args?.Length >= 2)
{
loopCount = args[1];
int benchType = int.Parse(args[0]);
if (args?.Length >= 3)
{
executionCount = int.Parse(args[2]);
}
switch (benchType)
{
case 1:
bench = new SimpleFibonacciLoopBench();
runnerThread = new Thread(() => {
for (int i = 0; i < executionCount; i++)
{
result = bench.run(loopCount);
results.Add(result);
}
});
break;
default:
bench = new SimpleFibonacciBench();
runnerThread = new Thread(() => {
for (int i = 0; i < executionCount; i++)
{
result = bench.run(loopCount);
results.Add(result);
}
}, 1024 * 1024 * 1024); //changes the thread stack size for the recursive
break;
}
}
else
{
bench = new SimpleFibonacciLoopBench();
runnerThread = new Thread(() => {
for (int i = 0; i < executionCount; i++)
{
result = bench.run(loopCount);
results.Add(result);
}
});
}
runnerThread.Start();
runnerThread.Join();
var totalMs = results
.Sum(r => r.RunningMilliseconds);
long averageMs = totalMs / executionCount;
object rawResult = results[0].value;
bool resultsOk = results.All(r => rawResult.ToString().Equals(r.value.ToString()));
if (!resultsOk)
{
Console.WriteLine("Execution problem, not all results are ok ='(");
Environment.Exit(-1);
}
Console.Write($"{averageMs} {rawResult.ToString()}");
}
