I’m working on a lock free stack and queue data stracture where I can place as many add items as I want and collect all the items in a single call, I think my design is solid and it is working as expected until I started to recive an unexpected exception which I thought is impossible in a pure C# envirement:
Managed Debugging Assistant ‘FatalExecutionEngineError’ has detected a problem Additional Information: The runtime has encountered a fatal error. The address of the error was at 0x6caf6ac7, on thread 0x16f0. The error code is 0xc0000005. This error may be a bug in the CLR or in the unsafe or non-verifiable portions of user code. Common sources of this bug include user marshaling errors for COM-interop or PInvoke, which may corrupt the stack.
I cant seem to be able to find way is it happening and would like to know if someone can direct me to the cause of the error:
This is the implemention of the stackbulkcollector:
public class StackBulkCollector<T> : IBulkCollector<T>
{
class Node
{
public T value;
private bool m_isSet;
private Node m_prev;
public Node(T data)
{
value = data;
}
public Node()
{
}
public Node Prev
{
set
{
m_prev = value;
m_isSet = true;
}
get
{
if (!m_isSet)
{
SpinWait s = new SpinWait();
while (!m_isSet)
{
s.SpinOnce();
}
}
return m_prev;
}
}
}
class Enumerable : IEnumerable<T>
{
private Node m_last;
public Enumerable(Node last)
{
m_last = last;
}
public IEnumerator<T> GetEnumerator()
{
return new Enumerator(m_last);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return new Enumerator(m_last);
}
}
class Enumerator : IEnumerator<T>
{
private readonly Node m_last;
private Node m_current;
public Enumerator(Node last)
{
var node = new Node();
m_current = m_last = node;
node.Prev = last;
}
public T Current
{
get { return m_current.value; }
}
public void Dispose()
{
}
object System.Collections.IEnumerator.Current
{
get { return this; }
}
public bool MoveNext()
{
if (m_current == null)
{
return false;
}
m_current = m_current.Prev;
return m_current != null;
}
public void Reset()
{
m_current = m_last;
}
}
private Node m_last;
public void Add(T data)
{
var node = new Node(data);
node.Prev = Interlocked.Exchange(ref m_last, node);
}
public IEnumerable<T> GetBulk()
{
var last = Interlocked.Exchange(ref m_last, null);
return new Enumerable(last);
}
}
And this is the tester program I use to test it:
class Program
{
public static readonly int UseThreads = 4;
public static readonly TimeSpan Duration = new TimeSpan(0,0,0,3);
public static long[] AddedItems = new long[UseThreads];
static void Main(string[] args)
{
IBulkCollector<TestData> bulkCollector = new QueuedBulkCollector<TestData>();
while (true)
{
using (var countdownEvent = new CountdownEvent(UseThreads + 1))
{
var results = new Dictionary<int, List<TestData>>();
if (bulkCollector is QueuedBulkCollector<TestData>)
{
bulkCollector = new StackBulkCollector<TestData>();
Console.WriteLine("Starting StackBulkCollector Test");
}
else
{
bulkCollector = new StackBulkCollector<TestData>();
Console.WriteLine("Starting QueuedBulkCollector Test");
}
for (int i = 0; i < UseThreads; i++)
{
results[i] = new List<TestData>();
Thread t = new Thread(PushTestData);
t.Start(new object[] {i, bulkCollector, countdownEvent});
}
var start = DateTime.Now;
Thread readerThred = new Thread(() =>
{
while ((DateTime.Now - start) <
(Duration - new TimeSpan(0, 0, 0, 0, 100)))
{
foreach (var testData in bulkCollector.GetBulk())
{
results[testData.Id].Add(testData);
}
//Console.WriteLine("Doing Some Read {0}", currBulk.Count);
System.Threading.Thread.Sleep(10);
}
countdownEvent.Signal();
});
readerThred.Start();
countdownEvent.Wait();
var lastBulk = bulkCollector.GetBulk().ToList();
foreach (var testData in lastBulk)
{
results[testData.Id].Add(testData);
}
Console.WriteLine("Doing Last Read {0}", lastBulk.Count);
long[] value = new long[UseThreads];
long totalCount = 0;
int errorCount = 0;
for (int i = 0; i < UseThreads; i++)
{
value[i] = AddedItems[i];
totalCount += value[i];
Console.WriteLine("Thread {0} Push {1} Items", i, value[i]);
var verifyArray = results[i].OrderBy(p => p.Value).ToList();
if (verifyArray.Count != value[i])
{
Console.WriteLine("Not Working Count miss match");
errorCount++;
}
else
{
var expected = 0;
foreach (var testData in verifyArray)
{
if (expected != testData.Value)
{
Console.WriteLine("NotWorking");
errorCount++;
}
expected++;
}
}
}
Console.WriteLine("Done Total Push {0} with {1} errors.", totalCount.ToString("#,##0") , errorCount);
if (errorCount != 0)
{
Console.ReadKey();
}
}
}
}
private static void PushTestData(object o)
{
object[] parms = o as object[];
int id = (int)parms[0];
IBulkCollector<TestData> bulkCollector = (IBulkCollector<TestData>)parms[1];
CountdownEvent endEvetn = (CountdownEvent)parms[2];
AddedItems[id] = 0;
var start = DateTime.Now;
while ((DateTime.Now - start) < Duration)
{
bulkCollector.Add(new TestData() { Id = id, Value = AddedItems[id]});
AddedItems[id]++;
}
endEvetn.Signal();
}
}
Any advice will be most welcome.
Sorry, A defective memory module was the cause of the problem, it has been replaced and the problem was solved.