// ReSharper disable once UnusedMember.Local
static void QueueTests()
{
/* The obvious facts (and rank):
*
* Non-synchronized:
* 1) Queue is the fastest when no sychronization is needed.
* 2) ConcurrentQueue isn't terribly slow, but definiltey slower than a regular queue for non-sychronized operations;
* 3) LockSynchronizedQueue is very slow for non-sychronized operations.
*
* Synchronized:
* ConcurrentQueue beats a LockSynchronizedQueue almost every time.
*/
var report = new BenchmarkConsoleReport <Func <IQueue <object> > >(500000, QueueParallelBenchmark.Results);
report.AddBenchmark("LockSynchronizedQueue",
count => () => new LockSynchronizedQueue <object>());
report.AddBenchmark("ConcurrentQueue",
count => () => new Queue.Concurrent <object>());
report.Pretest(200, 200); // Run once through first to scramble/warm-up initial conditions.
report.Test(50, 4);
report.Test(100, 8);
report.Test(250, 16);
report.Test(1000, 24);
report.Test(2000, 32);
report.Test(4000, 48);
}
static void CollectionTests()
{
//{
// var report = new BenchmarkConsoleReport<Func<ICollection<object>>>(1600000, (c, r, p) => CollectionBenchmark.Results(c, r, p));
// report.AddBenchmark("LinkedList",
// count => () => new LinkedList<object>());
// report.AddBenchmark("HashSet",
// count => () => new HashSet<object>());
// report.AddBenchmark("List",
// count => () => new List<object>());
// report.Pretest(200, 200); // Run once through first to scramble/warm-up initial conditions.
// report.Test(100);
// report.Test(250);
// report.Test(1000);
//}
Console.WriteLine("::: Synchronized Lists :::\n");
{
var report = new BenchmarkConsoleReport <Func <IList <object> > >(100000, ListParallelBenchmark.Results);
report.AddBenchmark("LockSynchronizedList",
count => () => new LockSynchronizedList <object>());
report.AddBenchmark("ReadWriteSynchronizedList",
count => () => new ReadWriteSynchronizedList <object>());
report.Pretest(200, 200); // Run once through first to scramble/warm-up initial conditions.
report.Test(100, 4);
report.Test(250, 4);
report.Test(1000, 4);
report.Test(2000, 4);
}
Console.WriteLine("::: Synchronized HashSets :::\n");
{
var report = new BenchmarkConsoleReport <Func <ICollection <object> > >(100000, CollectionParallelBenchmark.Results);
report.AddBenchmark("ConcurrentDictionary",
count => () => new ConcurrentHashSet <object>());
report.AddBenchmark("LockSynchronizedHashSet",
count => () => new LockSynchronizedHashSet <object>());
report.AddBenchmark("ReadWriteSynchronizedHashSet",
count => () => new ReadWriteSynchronizedHashSet <object>());
report.Pretest(200, 200); // Run once through first to scramble/warm-up initial conditions.
report.Test(100, 4);
report.Test(250, 4);
report.Test(1000, 4 * 4);
report.Test(2000, 8 * 4);
}
}
