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 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);
}
private bool RemoveNode(K key, Node node, TMVar <Node> bucketVar)
{
if (node == null)
{
return(false);
}
if (node.Key.Equals(key))
{
_size--;
bucketVar.Value = node.Next;
return(true);
}
while (node.Next != null && !key.Equals(node.Next.Value.Key))
{
node = node.Next.Value;
}
//node.Next == null || node.Next.Key == key
if (node.Next == null)
{
return(false);
}
_size--;
node.Next.Value = node.Next.Value.Next;
return(true);
}
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);
}
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);
}
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 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 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);
}
public void TestDynamicTypeInTMVar()
{
const string stringForTest = "abc";
var dyna = new TMVar <dynamic>(0);
STMSystem.Atomic(() => dyna.Value = stringForTest);
Assert.AreEqual(stringForTest, dyna.Value);
}
private void InsertInBucket(TMVar <Node> bucketVar, Node node)
{
var curNode = bucketVar.Value;
if (curNode != null)
{
node.Next.Value = curNode;
}
bucketVar.Value = node;
}
/// <summary>
/// Creates and initializes the backing array
/// </summary>
/// <param name="nrBuckets"></param>
/// <returns></returns>
private TMVar <Node>[] MakeBuckets(int nrBuckets)
{
var temp = new TMVar <Node> [nrBuckets];
for (var i = 0; i < nrBuckets; i++)
{
temp[i] = new TMVar <Node>();
}
return(temp);
}
/// <summary>
/// Creates and initializes the backing array
/// </summary>
/// <param name="nrBuckets"></param>
/// <returns></returns>
private TMVar <ImmutableList <Node> >[] MakeBuckets(int nrBuckets)
{
var temp = new TMVar <ImmutableList <Node> > [nrBuckets];
for (var i = 0; i < nrBuckets; i++)
{
temp[i] = new TMVar <ImmutableList <Node> >(ImmutableList.Create <Node>());
}
return(temp);
}
private static void DinningPhilosophersTest()
{
var fork1 = new TMVar <bool>(true);
var fork2 = new TMVar <bool>(true);
var fork3 = new TMVar <bool>(true);
var fork4 = new TMVar <bool>(true);
var fork5 = new TMVar <bool>(true);
StartPhilosopher(fork1, fork2);
StartPhilosopher(fork2, fork3);
StartPhilosopher(fork3, fork4);
StartPhilosopher(fork4, fork5);
StartPhilosopher(fork5, fork1);
}
public void Setup()
{
var eatCounter = new TMInt(0);
var fork1 = new TMVar <bool>(true);
var fork2 = new TMVar <bool>(true);
var fork3 = new TMVar <bool>(true);
var fork4 = new TMVar <bool>(true);
var fork5 = new TMVar <bool>(true);
t1 = CreatePhilosopher(eatCounter, fork1, fork2);
t2 = CreatePhilosopher(eatCounter, fork2, fork3);
t3 = CreatePhilosopher(eatCounter, fork3, fork4);
t4 = CreatePhilosopher(eatCounter, fork4, fork5);
t5 = CreatePhilosopher(eatCounter, fork5, fork1);
}
public static void TMVarExample()
{
TMVar <string> tmString = new TMVar <string>("abc");
TMVar <bool> tmBool = new TMVar <bool>();
TMVar <Person> tmPerson = new TMVar <Person>(new Person("Bo Hansen", 57));
TMInt tmInt = new TMInt(12);
STMSystem.Atomic(() =>
{
if (tmBool && tmString == "abc")
{
tmInt++;
}
});
}
public void NestingEnclosingWriteTest()
{
TMVar <string> s = new TMVar <string>(string.Empty);
var result = STMSystem.Atomic(() =>
{
s.Value = "abc";
STMSystem.Atomic(() =>
{
s.Value = s + "def";
});
return(s.Value);
});
Assert.AreEqual <string>(result, "abcdef");
}
private static void DinningPhilosophersTest()
{
var eatCounter = new LockCounter();
var fork1 = new TMVar <bool>(true);
var fork2 = new TMVar <bool>(true);
var fork3 = new TMVar <bool>(true);
var fork4 = new TMVar <bool>(true);
var fork5 = new TMVar <bool>(true);
var t1 = StartPhilosopher(eatCounter, fork1, fork2);
var t2 = StartPhilosopher(eatCounter, fork2, fork3);
var t3 = StartPhilosopher(eatCounter, fork3, fork4);
var t4 = StartPhilosopher(eatCounter, fork4, fork5);
var t5 = StartPhilosopher(eatCounter, fork5, fork1);
t1.Join();
t2.Join();
t3.Join();
t4.Join();
t5.Join();
}
public void NestingOrElseTest2()
{
var tm1 = new TMVar <int>(1);
var tm2 = new TMVar <int>(2);
STMSystem.Atomic(() =>
{
tm1.Value = 10;
STMSystem.Atomic(() =>
{
tm1.Value = 20;
});
var temp = tm1.Value;
tm2.Value = temp * temp;
});
Assert.IsTrue(tm2.Value == 400);
}
public static void NestingExample()
{
TMVar <string> s = new TMVar <string>(string.Empty);
var result = STMSystem.Atomic(() =>
{
s.Value = "abc";
STMSystem.Atomic(() =>
{
s.Value = s + "def";
});
return(s.Value);
});
STM.Collections.Queue <Person> buffer1 = new STM.Collections.Queue <Person>();
STM.Collections.Queue <Person> buffer2 = new STM.Collections.Queue <Person>();
STMSystem.Atomic(() =>
{
var item = buffer1.Dequeue();
buffer2.Enqueue(item);
});
}
public void TestOrElse()
{
var result = 0;
var tm1 = new TMVar <bool>(false);
var tm2 = new TMVar <bool>(false);
var t1 = new Thread(() =>
{
result = STMSystem.Atomic(() =>
{
if (!tm1)
{
STMSystem.Retry();
}
return(1);
},
() =>
{
if (!tm2)
{
STMSystem.Retry();
}
return(2);
}
);
});
t1.Start();
Thread.Sleep(100);
STMSystem.Atomic(() => tm2.Value = true);
t1.Join();
Assert.AreEqual(2, result);
}
private static Thread StartPhilosopher(LockCounter eatCounter, TMVar <bool> left, TMVar <bool> right)
{
var t1 = new Thread(() =>
{
while (eatCounter.Get() < MAX_EAT_COUNT)
{
STMSystem.Atomic(() =>
{
if (!left || !right)
{
STMSystem.Retry();
}
left.Value = false;
right.Value = false;
});
Console.WriteLine("Thread: " + Thread.CurrentThread.ManagedThreadId + " eating.");
Thread.Sleep(100);
Console.WriteLine("Eat count: " + eatCounter.IncrementAndGet());
STMSystem.Atomic(() =>
{
left.Value = true;
right.Value = true;
});
Thread.Sleep(100);
}
});
t1.Start();
return(t1);
}
private static void JVSpeedTest()
{
var b = new VBox <bool>();
var tmb = new TMVar <bool>();
var sw = Stopwatch.StartNew();
for (int i = 0; i < 10000; i++)
{
bool notCommitted = true;
while (notCommitted)
{
var t = JVTransaction.Start();
b.Put(t, !b.Read(t));
notCommitted = !t.Commit();
}
}
sw.Stop();
Console.WriteLine("Non system time: " + sw.ElapsedMilliseconds);
sw = Stopwatch.StartNew();
for (int i = 0; i < 10000; i++)
{
JVSTMSystem.Atomic((t) =>
{
if (b.Read(t))
{
b.Put(t, false);
}
else
{
b.Put(t, true);
}
});
}
sw.Stop();
Console.WriteLine("System time: " + sw.ElapsedMilliseconds);
sw = Stopwatch.StartNew();
for (int i = 0; i < 10000; i++)
{
STMSystem.Atomic(() =>
{
if (tmb.Value)
{
tmb.Value = false;
}
else
{
tmb.Value = true;
}
});
}
sw.Stop();
Console.WriteLine("TL2 time: " + sw.ElapsedMilliseconds);
}
public Fork()
{
State = new TMVar <bool>(true);
}
public void Setup()
{
_tmString = SetupInternal();
}
public Node(K key, V value)
{
Key = key;
Value = new TMVar <V>(value);
Next = new TMVar <Node>();
}
public SingleItemBuffer(T initial)
{
_item = new TMVar <T>(initial);
_full = new TMVar <bool>(true);
}
public SingleItemBuffer()
{
_item = new TMVar <T>(default(T));
_full = new TMVar <bool>(false);
}
