public bool Remove(T item)
{
return(STMSystem.Atomic(() =>
{
Node prevNode = null;
var node = _head.Value;
while (node != null)
{
if (node.Item.Equals(item))
{
if (prevNode != null)
{
prevNode.Next.Value = node.Next.Value;
}
_size--;
return true;
}
prevNode = node;
node = node.Next.Value;
}
return false;
}));
}
private int NonTransactionalWriteTestInternal()
{
var result = new TMVar <int>(10);
var t1 = new Thread(() =>
{
var r1 = STMSystem.Atomic(() =>
{
if (result.Value == 10)
{
Thread.Yield();
result.SetValue(result.Value * 10);
}
return(result.GetValue());
});
});
var t2 = new Thread(() => result.Value = 12);
t1.Start();
t2.Start();
t1.Join();
t2.Join();
return(result.Value);
}
public void NestingOrElseTest3()
{
var tm1 = new TMVar <int>(1);
var tm2 = new TMVar <int>(2);
STMSystem.Atomic(() =>
{
tm1.Value = 10;
STMSystem.Atomic(() =>
{
if (tm1.Value == 10)
{
STMSystem.Retry();
}
tm1.Value = 20;
},
() =>
{
tm1.Value = 50;
});
var temp = tm1.Value;
tm2.Value = temp * temp;
});
Assert.IsTrue(tm2.Value == 2500);
}
public T Dequeue()
{
return(STMSystem.Atomic(() =>
{
#if DEBUG
Console.WriteLine("Dequeue by: " + Transaction.LocalTransaction.ID);
#endif
if (_size.Value == 0)
{
STMSystem.Retry();
}
var oldHead = _head.Value;
var newHead = oldHead.Next.Value;
var value = oldHead.Value;
_head.Value = newHead;
if (newHead == null)
{
_tail.Value = null;
}
_size.Value = _size.Value - 1;
return value;
}));
}
public void NestingOrElseTest()
{
var buffer1 = new STM.Collections.Queue <int>();
var buffer2 = new STM.Collections.Queue <int>();
buffer2.Enqueue(10);
var result = STMSystem.Atomic(() =>
{
if (buffer1.Count == 0)
{
STMSystem.Retry();
}
return(buffer1.Dequeue());
},
() =>
{
if (buffer2.Count == 0)
{
STMSystem.Retry();
}
return(buffer2.Dequeue());
});
Assert.IsTrue(result == 10);
Assert.IsTrue(buffer1.Count == 0);
Assert.IsTrue(buffer2.Count == 0);
}
public void MaxAttemptsTest()
{
STMSystem.Atomic(() =>
{
throw new STMAbortException();
});
}
public void TestRetry()
{
var result = new TMVar <int>(10);
var t1 = new Thread(() => STMSystem.Atomic(() =>
{
var tmp = result.Value;
if (tmp != 12)
{
STMSystem.Retry();
}
result.Value = tmp * 10;
return(result.Value);
}));
var t2 = new Thread(() => STMSystem.Atomic(() =>
{
Thread.Sleep(100);
result.Value = 12;
}));
t1.Start();
t2.Start();
t1.Join();
t2.Join();
Assert.AreEqual(120, result.Value);
}
private Thread CreatePhilosopher(TMInt eatCounter, TMVar <bool> left, TMVar <bool> right)
{
var t1 = new Thread(() =>
{
while (eatCounter < MAX_EAT_COUNT)
{
STMSystem.Atomic(() =>
{
if (!left || !right)
{
STMSystem.Retry();
}
left.Value = false;
right.Value = false;
});
Thread.Sleep(100);
++eatCounter;
STMSystem.Atomic(() =>
{
left.Value = true;
right.Value = true;
});
Thread.Sleep(100);
}
});
return(t1);
}
public override bool Remove(K key)
{
return(STMSystem.Atomic(() =>
{
if (_resizing)
{
STMSystem.Retry();
}
var bucketIndex = GetBucketIndex(key);
//TMVar wrapping the immutable chain list
var bucketVar = _buckets.Value[bucketIndex];
var node = FindNode(key, bucketVar.Value);
if (node != null)
{
//If node is not found key does not exist so insert
bucketVar.Value = bucketVar.Value.Remove(node);
_size--;
return true;
}
return false;
}));
}
private static void StartPhilosopher(TMVar <bool> left, TMVar <bool> right)
{
var t1 = new Thread(() =>
{
while (true)
{
STMSystem.Atomic(() =>
{
if (!left || !right)
{
STMSystem.Retry();
}
left.Value = false;
right.Value = false;
});
Thread.Sleep(100);
STMSystem.Atomic(() =>
{
left.Value = true;
right.Value = true;
});
Thread.Sleep(100);
}
});
t1.Start();
}
private static int Test4Internal()
{
var result = new TMVar <ValueHolder>(new ValueHolder(10));
var t1 = new Thread(() =>
{
var r1 = STMSystem.Atomic(() =>
{
if (result.GetValue().Value == 10)
{
Thread.Yield();
result.SetValue(new ValueHolder(result.GetValue().Value * 10));
}
return(result.GetValue());
});
Debug.Assert(r1.Value != 120, "String value: " + r1.Value);
});
var t2 = new Thread(() => STMSystem.Atomic(() => result.SetValue(new ValueHolder(12))));
t1.Start();
t2.Start();
t1.Join();
t2.Join();
return(result.GetValue().Value);
}
public override void Add(K key, V value)
{
STMSystem.Atomic(() =>
{
if (_resizing)
{
STMSystem.Retry();
}
var bucketIndex = GetBucketIndex(key);
//TMVar wrapping the immutable chain list
var bucketVar = _buckets.Value[bucketIndex];
var node = FindNode(key, bucketVar.Value);
if (node != null)
{
//If node is not null key exist in map. Update the value
node.Value.Value = value;
}
else
{
//Else inser the node
bucketVar.Value = bucketVar.Value.Add(CreateNode(key, value));
_size++;
}
});
var resize = STMSystem.Atomic(() => ResizeIfNeeded());
if (resize)
{
STMSystem.Atomic(Resize);
}
}
private int RaceTest1Internal()
{
var result = new TMVar <int>(10);
var t1 = new Task(() =>
{
STMSystem.Atomic(() =>
{
if (result.Value == 10)
{
Thread.Yield();
result.SetValue(result.Value * 10);
}
return(result.GetValue());
});
});
var t2 = new Task(() => STMSystem.Atomic(() =>
{
result.Value = 12;
}));
t1.Start();
t2.Start();
t1.Wait();
t2.Wait();
return(result.Value);
}
private Task StartPhilosopher(Fork left, Fork right)
{
var t1 = new Task(() =>
{
while (eatCounter < MAX_EAT_COUNT)
{
STMSystem.Atomic(() =>
{
left.AttemptToPickUp();
right.AttemptToPickUp();
});
Console.WriteLine("Thread: " + Thread.CurrentThread.ManagedThreadId + " eating.");
Thread.Sleep(100);
Console.WriteLine("Eat count: " + ++eatCounter);
STMSystem.Atomic(() =>
{
left.State.Value = true;
right.State.Value = true;
});
Thread.Sleep(100);
}
});
t1.Start();
return(t1);
}
private void HandleElfs()
{
Console.WriteLine("3 elfs at the door!");
STMSystem.Atomic(() =>
{
foreach (var elf in _eBuffer)
{
elf.AskQuestion();
}
});
//Answer questions
Thread.Sleep(100);
//Back to work incompetent elfs!
STMSystem.Atomic(() =>
{
for (int i = 0; i < SCStats.MAX_ELFS; i++)
{
var elf = _eBuffer.Dequeue();
elf.BackToWork();
}
});
Console.WriteLine("Elfs helped");
}
public void TMIntDivTest()
{
STMSystem.Atomic(() =>
{
_tmInt.Value = _tmInt / 5;
});
Assert.AreEqual <int>(1, _tmInt.Value);
}
public void CallToSleigh()
{
STMSystem.Atomic(() =>
{
_waitingInHut.Value = false;
_waitingAtSleigh.Value = true;
});
}
public void TMIntModTest()
{
STMSystem.Atomic(() =>
{
_tmInt.Value = _tmInt % 3;
});
Assert.AreEqual <int>(2, _tmInt.Value);
}
public void HelpDeliverPresents()
{
STMSystem.Atomic(() =>
{
_waitingAtSleigh.Value = false;
_workingForSanta.Value = true;
});
}
public void Add(T item)
{
STMSystem.Atomic(() =>
{
_head.Value = new Node(item, _head);
_size++;
});
}
public void TestDynamicTypeInTMVar()
{
const string stringForTest = "abc";
var dyna = new TMVar <dynamic>(0);
STMSystem.Atomic(() => dyna.Value = stringForTest);
Assert.AreEqual(stringForTest, dyna.Value);
}
public void TMIntMinusTest()
{
STMSystem.Atomic(() =>
{
_tmInt.Value = _tmInt - 5;
});
Assert.AreEqual <int>(0, _tmInt.Value);
}
public void TMIntTimesTest()
{
STMSystem.Atomic(() =>
{
_tmInt.Value = _tmInt * 5;
});
Assert.AreEqual <int>(25, _tmInt.Value);
}
public void Enqueue(T value)
{
STMSystem.Atomic(() =>
{
var node = new Node(value);
var curTail = _tail.Value;
curTail.Next.Value = node;
_tail.Value = node;
});
}
private static void TestRetry2()
{
Console.WriteLine("Retry as only operation:");
var t1 = new Thread(() =>
{
STMSystem.Atomic(STMSystem.Retry);
});
t1.Start();
t1.Join();
}
public void AttemptToPickUp()
{
STMSystem.Atomic(() =>
{
if (!State.Value)
{
STMSystem.Retry();
}
State.Value = false;
});
}
public void ExceptionInTransaction()
{
TMInt i = new TMInt(0);
TMInt j = new TMInt(0);
STMSystem.Atomic(() =>
{
i.Value = 1;
throw new InvalidOperationException();
j.Value = 1;
});
}
public override bool ContainsKey(K key)
{
return(STMSystem.Atomic(() =>
{
if (_resizing)
{
STMSystem.Retry();
}
return FindNode(key) != null;
}));
}
public override bool Remove(K key)
{
return(STMSystem.Atomic(() =>
{
var bucketIndex = GetBucketIndex(key);
//TMVar wrapping the immutable chain list
var bucketVar = _buckets.Value[bucketIndex];
var firstNode = bucketVar.Value;
return RemoveNode(key, firstNode, bucketVar);
}));
}
public void SetValue(T value)
{
STMSystem.Atomic(() =>
{
if (_full.GetValue())
{
STMSystem.Retry();
}
_full.SetValue(true);
_item.SetValue(value);
});
}
