//******************************************************************************************************// ConcurrentIsolatedQueueTest.cs - Gbtc//// Copyright © 2013, Grid Protection Alliance. All Rights Reserved.//// Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See// the NOTICE file distributed with this work for additional information regarding copyright ownership.// The GPA licenses this file to you under the MIT License (MIT), the "License"; you may// not use this file except in compliance with the License. You may obtain a copy of the License at://// http://www.opensource.org/licenses/MIT//// Unless agreed to in writing, the subject software distributed under the License is distributed on an// "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the// License for the specific language governing permissions and limitations.//// Code Modification History:// ----------------------------------------------------------------------------------------------------// 1/4/2013 - Steven E. Chisholm// Generated original version of source code. ////****************************************************************************************************** using System;using System.Collections.Concurrent;using System.Collections.Generic;using System.Diagnostics;using System.Threading;using GSF.Collections;using Microsoft.VisualStudio.TestTools.UnitTesting; namespace GSF.Core.Tests.GSF.Collections{ [TestClass] public class ConcurrentIsolatedQueueTest { private ConcurrentIsolatedQueue<Tuple<int>> m_collection; private const int cnt = 1000000; private ManualResetEvent m_wait; //[TestMethod] public void BenchmarkWrite() { string value = null; int x = 0; const int cnt = 10000; const int loop = 10000; List<string> items = new List<string>(cnt); for (x = 0; x < cnt; x++) { items.Add(x.ToString()); } var queue = new ConcurrentIsolatedQueue<string>(); Stopwatch swDequeue = new Stopwatch(); Stopwatch swEnqueue = new Stopwatch(); for (int repeat = 0; repeat < loop; repeat++) { swEnqueue.Start(); foreach (var item in items) queue.Enqueue(item); swEnqueue.Stop(); swDequeue.Start(); while (queue.TryDequeue(out value)) ; swDequeue.Stop(); } swEnqueue.Reset(); swDequeue.Reset(); for (int repeat = 0; repeat < loop; repeat++) { swEnqueue.Start(); foreach (var item in items) queue.Enqueue(item); swEnqueue.Stop(); swDequeue.Start(); while (queue.TryDequeue(out value)) ; swDequeue.Stop(); } System.Console.WriteLine("Enqueue " + (cnt * loop / swEnqueue.Elapsed.TotalSeconds / 1000000)); System.Console.WriteLine("Dequeue " + (cnt * loop / swDequeue.Elapsed.TotalSeconds / 1000000)); System.Console.WriteLine(swDequeue.Elapsed.TotalSeconds); } //[TestMethod] public void BenchmarkConcurrentQueue() { string value = null; int x = 0; const int cnt = 10000; const int loop = 5000; List<string> items = new List<string>(cnt); for (x = 0; x < cnt; x++) { items.Add(x.ToString()); } var queue = new ConcurrentQueue<string>(); Stopwatch swDequeue = new Stopwatch(); Stopwatch swEnqueue = new Stopwatch(); for (int repeat = 0; repeat < loop; repeat++) { swEnqueue.Start(); foreach (var item in items) queue.Enqueue(item); swEnqueue.Stop(); swDequeue.Start(); while (queue.TryDequeue(out value)) ; swDequeue.Stop(); } swEnqueue.Reset(); swDequeue.Reset(); for (int repeat = 0; repeat < loop; repeat++) { swEnqueue.Start(); foreach (var item in items) queue.Enqueue(item); swEnqueue.Stop(); swDequeue.Start(); while (queue.TryDequeue(out value)) ; swDequeue.Stop(); } System.Console.WriteLine("Enqueue " + (cnt * loop / swEnqueue.Elapsed.TotalSeconds / 1000000)); System.Console.WriteLine("Dequeue " + (cnt * loop / swDequeue.Elapsed.TotalSeconds / 1000000)); System.Console.WriteLine(swDequeue.Elapsed.TotalSeconds); } [TestMethod] public void Test() { m_wait = new ManualResetEvent(false); m_collection = new ConcurrentIsolatedQueue<Tuple<int>>(); ThreadPool.QueueUserWorkItem(RunTwo); m_wait.WaitOne(); m_wait.Reset(); Stopwatch sw = new Stopwatch(); sw.Start(); for (int x = 0; x < cnt; x++) { if (x % 10000 == 0) { System.Console.WriteLine(m_collection.Count); Thread.Sleep(1); } m_collection.Enqueue(new Tuple<int>(x)); } sw.Stop(); System.Console.WriteLine(sw.Elapsed.TotalSeconds); m_wait.WaitOne(); } private void RunTwo(object state) { m_wait.Set(); //SpinWait wait = new SpinWait(); //Thread.Sleep(1000); Stopwatch sw = new Stopwatch(); sw.Start(); Tuple<int> value; int count = 0; int countRepeats = 0; while (count < cnt) { while (m_collection.TryDequeue(out value)) { Assert.AreEqual(count, value.Item1); count++; } countRepeats++; Thread.Sleep(1); } sw.Stop(); System.Console.WriteLine(sw.Elapsed.TotalSeconds); System.Console.WriteLine(countRepeats); m_wait.Set(); Assert.AreEqual(count, cnt); } [TestMethod] public void TestCount() { m_collection = new ConcurrentIsolatedQueue<Tuple<int>>(); Tuple<int> value; long count = 0; for (int x = 0; x < 100000; x++) { if (m_collection.Count != count) Assert.Fail("Count is wrong"); m_collection.Enqueue(new Tuple<int>(x)); count++; if (x % 10 == 0) { m_collection.TryDequeue(out value); { count--; if (m_collection.Count != count) Assert.Fail("Count is wrong"); } } } while (m_collection.TryDequeue(out value)) { count--; if (m_collection.Count != count) Assert.Fail("Count is wrong"); } } }}
//******************************************************************************************************
// ConcurrentIsolatedQueueTest.cs - Gbtc
//
// Copyright © 2013, Grid Protection Alliance. All Rights Reserved.
//
// Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
// the NOTICE file distributed with this work for additional information regarding copyright ownership.
// The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
// not use this file except in compliance with the License. You may obtain a copy of the License at:
//
// http://www.opensource.org/licenses/MIT
//
// Unless agreed to in writing, the subject software distributed under the License is distributed on an
// "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
// License for the specific language governing permissions and limitations.
//
// Code Modification History:
// ----------------------------------------------------------------------------------------------------
// 1/4/2013 - Steven E. Chisholm
// Generated original version of source code.
//
//******************************************************************************************************
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using GSF.Collections;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace GSF.Core.Tests.GSF.Collections
{
[TestClass]
public class ConcurrentIsolatedQueueTest
{
private ConcurrentIsolatedQueue<Tuple<int>> m_collection;
private const int cnt = 1000000;
private ManualResetEvent m_wait;
//[TestMethod]
public void BenchmarkWrite()
{
string value = null;
int x = 0;
const int cnt = 10000;
const int loop = 10000;
List<string> items = new List<string>(cnt);
for (x = 0; x < cnt; x++)
{
items.Add(x.ToString());
}
var queue = new ConcurrentIsolatedQueue<string>();
Stopwatch swDequeue = new Stopwatch();
Stopwatch swEnqueue = new Stopwatch();
for (int repeat = 0; repeat < loop; repeat++)
{
swEnqueue.Start();
foreach (var item in items)
queue.Enqueue(item);
swEnqueue.Stop();
swDequeue.Start();
while (queue.TryDequeue(out value))
;
swDequeue.Stop();
}
swEnqueue.Reset();
swDequeue.Reset();
for (int repeat = 0; repeat < loop; repeat++)
{
swEnqueue.Start();
foreach (var item in items)
queue.Enqueue(item);
swEnqueue.Stop();
swDequeue.Start();
while (queue.TryDequeue(out value))
;
swDequeue.Stop();
}
System.Console.WriteLine("Enqueue " + (cnt * loop / swEnqueue.Elapsed.TotalSeconds / 1000000));
System.Console.WriteLine("Dequeue " + (cnt * loop / swDequeue.Elapsed.TotalSeconds / 1000000));
System.Console.WriteLine(swDequeue.Elapsed.TotalSeconds);
}
//[TestMethod]
public void BenchmarkConcurrentQueue()
{
string value = null;
int x = 0;
const int cnt = 10000;
const int loop = 5000;
List<string> items = new List<string>(cnt);
for (x = 0; x < cnt; x++)
{
items.Add(x.ToString());
}
var queue = new ConcurrentQueue<string>();
Stopwatch swDequeue = new Stopwatch();
Stopwatch swEnqueue = new Stopwatch();
for (int repeat = 0; repeat < loop; repeat++)
{
swEnqueue.Start();
foreach (var item in items)
queue.Enqueue(item);
swEnqueue.Stop();
swDequeue.Start();
while (queue.TryDequeue(out value))
;
swDequeue.Stop();
}
swEnqueue.Reset();
swDequeue.Reset();
for (int repeat = 0; repeat < loop; repeat++)
{
swEnqueue.Start();
foreach (var item in items)
queue.Enqueue(item);
swEnqueue.Stop();
swDequeue.Start();
while (queue.TryDequeue(out value))
;
swDequeue.Stop();
}
System.Console.WriteLine("Enqueue " + (cnt * loop / swEnqueue.Elapsed.TotalSeconds / 1000000));
System.Console.WriteLine("Dequeue " + (cnt * loop / swDequeue.Elapsed.TotalSeconds / 1000000));
System.Console.WriteLine(swDequeue.Elapsed.TotalSeconds);
}
[TestMethod]
public void Test()
{
m_wait = new ManualResetEvent(false);
m_collection = new ConcurrentIsolatedQueue<Tuple<int>>();
ThreadPool.QueueUserWorkItem(RunTwo);
m_wait.WaitOne();
m_wait.Reset();
Stopwatch sw = new Stopwatch();
sw.Start();
for (int x = 0; x < cnt; x++)
{
if (x % 10000 == 0)
{
System.Console.WriteLine(m_collection.Count);
Thread.Sleep(1);
}
m_collection.Enqueue(new Tuple<int>(x));
}
sw.Stop();
System.Console.WriteLine(sw.Elapsed.TotalSeconds);
m_wait.WaitOne();
}
private void RunTwo(object state)
{
m_wait.Set();
//SpinWait wait = new SpinWait();
//Thread.Sleep(1000);
Stopwatch sw = new Stopwatch();
sw.Start();
Tuple<int> value;
int count = 0;
int countRepeats = 0;
while (count < cnt)
{
while (m_collection.TryDequeue(out value))
{
Assert.AreEqual(count, value.Item1);
count++;
}
countRepeats++;
Thread.Sleep(1);
}
sw.Stop();
System.Console.WriteLine(sw.Elapsed.TotalSeconds);
System.Console.WriteLine(countRepeats);
m_wait.Set();
Assert.AreEqual(count, cnt);
}
[TestMethod]
public void TestCount()
{
m_collection = new ConcurrentIsolatedQueue<Tuple<int>>();
Tuple<int> value;
long count = 0;
for (int x = 0; x < 100000; x++)
{
if (m_collection.Count != count)
Assert.Fail("Count is wrong");
m_collection.Enqueue(new Tuple<int>(x));
count++;
if (x % 10 == 0)
{
m_collection.TryDequeue(out value);
{
count--;
if (m_collection.Count != count)
Assert.Fail("Count is wrong");
}
}
}
while (m_collection.TryDequeue(out value))
{
count--;
if (m_collection.Count != count)
Assert.Fail("Count is wrong");
}
}
}
}