public void BasicMultiThreadedCounts()
{
var obj = new object();
var counter = new ReferenceCounter();
var t1 = Task.Run(() => {
for (int i = 0; i < 100000; i++)
{
counter.AddReference(obj);
counter.AddReference(obj);
counter.Release(obj);
counter.Release(obj);
}
});
var t2 = Task.Run(() => {
for (int i = 0; i < 100000; i++)
{
counter.AddReference(obj);
counter.AddReference(obj);
counter.Release(obj);
counter.Release(obj);
}
});
Task.WaitAll(t1, t2);
Assert.False(counter.HasReference(obj));
}
public void BasicSingleThreadedCounts()
{
var obj = new object();
var counter = new ReferenceCounter();
Assert.False(counter.HasReference(obj));
counter.AddReference(obj);
Assert.True(counter.HasReference(obj));
counter.AddReference(obj);
Assert.True(counter.HasReference(obj));
counter.Release(obj);
Assert.True(counter.HasReference(obj));
counter.Release(obj);
Assert.False(counter.HasReference(obj));
}
public void ResizingThreadTableWorks()
{
var defaultThreadTableSize = Environment.ProcessorCount;
var threads = new List <WaitHandle>();
var counter = new ReferenceCounter();
var obj = new object();
for (int threadNumber = 0; threadNumber < defaultThreadTableSize * 2; threadNumber++)
{
var thread = new Thread(new ThreadStart(() =>
{
var handle = new AutoResetEvent(false);
threads.Add(handle);
for (int itteration = 0; itteration < 100; itteration++)
{
counter.AddReference(obj);
Thread.Sleep(10);
counter.Release(obj);
}
handle.Set();
}));
thread.Start();
}
WaitHandle.WaitAll(threads.ToArray());
Assert.False(counter.HasReference(obj));
}
/// <summary>
/// Gets or sets the element that has the specified key in the map.
/// </summary>
/// <param name="key">The key to locate.</param>
/// <returns>The element that has the specified key in the map.</returns>
public StackItem this[PrimitiveType key]
{
get
{
if (key.Size > MaxKeySize)
{
throw new ArgumentException($"MaxKeySize exceed: {key.Size}");
}
return(dictionary[key]);
}
set
{
if (key.Size > MaxKeySize)
{
throw new ArgumentException($"MaxKeySize exceed: {key.Size}");
}
if (ReferenceCounter != null)
{
if (dictionary.TryGetValue(key, out StackItem old_value))
{
ReferenceCounter.RemoveReference(old_value, this);
}
else
{
ReferenceCounter.AddReference(key, this);
}
ReferenceCounter.AddReference(value, this);
}
dictionary[key] = value;
}
}
public StackItem this[int index]
{
get
{
return(_array[index]);
}
set
{
ReferenceCounter?.RemoveReference(_array[index], this);
_array[index] = value;
ReferenceCounter?.AddReference(value, this);
}
}
internal DisposableReservation(OwnedMemory <T> owner)
{
_owner = owner;
switch (ReferenceCountingSettings.OwnedMemory)
{
case ReferenceCountingMethod.Interlocked:
((IKnown)_owner).AddReference();
break;
case ReferenceCountingMethod.ReferenceCounter:
ReferenceCounter.AddReference(_owner);
break;
case ReferenceCountingMethod.None:
break;
}
}
public Array(ReferenceCounter referenceCounter, IEnumerable <StackItem> value = null)
: base(referenceCounter)
{
_array = value switch
{
null => new List <StackItem>(),
List <StackItem> list => list,
_ => new List <StackItem>(value)
};
if (referenceCounter != null)
{
foreach (StackItem item in _array)
{
referenceCounter.AddReference(item, this);
}
}
}
public void ResizingObjectTableWorks()
{
var defaultObjectTableSize = 16;
var objects = new List <object>();
for (int objectNumber = 0; objectNumber < defaultObjectTableSize * 2; objectNumber++)
{
var obj = new object();
ReferenceCounter.AddReference(obj);
objects.Add(obj);
}
foreach (var obj in objects)
{
ReferenceCounter.Release(obj);
}
foreach (var obj in objects)
{
Assert.False(ReferenceCounter.HasReference(obj));
}
}
protected void AddReferenceCore()
{
ReferenceCount.AddReference();
}
public void Add(StackItem item)
{
_array.Add(item);
ReferenceCounter?.AddReference(item, this);
}
protected void AddReferenceInternal()
{
Process.AddReference();
_referenceCounter.AddReference();
}
public ExecutionPath AddReference()
{
ReferenceCount.AddReference();
return(this);
}
