public void Assert_Coherency_TrySwap()
{
const int NumIterations = 1_000_000;
var runner = NewRunner(new DummyImmutableRef(0L));
runner.AllThreadsTearDown = target => FastAssertEqual(NumIterations, target.Value.LongProp);
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
var newValue = new DummyImmutableRef(curValue.LongProp + 1L);
var prevValue = target.TrySwap(newValue, curValue);
var wasSet = prevValue.Equals(curValue);
var setValue = wasSet ? newValue : prevValue;
if (wasSet)
{
FastAssertEqual(curValue, prevValue);
FastAssertEqual(newValue, setValue);
}
else
{
FastAssertNotEqual(curValue, prevValue);
FastAssertEqual(setValue, prevValue);
}
}
}
);
runner.AllThreadsTearDown = null;
}
public void FastTryExchange()
{
const int NumIterations = 1_000_000;
var runner = NewRunner(new DummyImmutableRef(0L));
// (T, T)
runner.AllThreadsTearDown = target => AssertAreEqual(NumIterations, target.Value.LongProp);
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
var newValue = new DummyImmutableRef(curValue.LongProp + 1L);
var prevValue = target.FastTryExchange(newValue, curValue);
var wasSet = prevValue.Equals(curValue);
var setValue = wasSet ? newValue : prevValue;
if (wasSet)
{
AssertAreEqualObjects(curValue, prevValue);
AssertAreEqualObjects(newValue, setValue);
}
else
{
AssertAreNotEqualObjects(curValue, prevValue);
AssertAreEqualObjects(setValue, prevValue);
}
}
}
);
runner.AllThreadsTearDown = null;
}
public void TryExchangeWithContext()
{
const int NumIterations = 100_000;
var runner = NewRunner(new DummyImmutableRef(0L));
// Func(T, Func<T, T, TContext, bool>)
runner.ExecuteContinuousCoherencyTests(
target => {
var curValue = target.Value;
var newValue = new DummyImmutableRef(curValue.LongProp + 1L);
target.TryExchange(newValue, (c, n, ctx) => c.LongProp == n.LongProp - ctx, 1L);
},
NumIterations,
target => target.Value,
(prev, cur) => FastAssertTrue(cur.LongProp >= prev.LongProp)
);
// (Func<T, TContext, T>, T)
runner.AllThreadsTearDown = target => FastAssertEqual(NumIterations, target.Value.LongProp);
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
var(wasSet, prevValue, CurrentValue) = target.TryExchange((c, ctx) => new DummyImmutableRef(c.LongProp + ctx), 1L, curValue);
if (wasSet)
{
FastAssertEqual(curValue, prevValue);
FastAssertEqual((object)(prevValue.LongProp + 1L), CurrentValue.LongProp);
}
else
{
FastAssertNotEqual(curValue, prevValue);
}
}
}
);
runner.AllThreadsTearDown = null;
// (Func<T, TContext, T>, Func<T, T, bool>)
runner.ExecuteFreeThreadedTests(
target => {
var(wasSet, prevValue, CurrentValue) = target.TryExchange((c, ctx) => new DummyImmutableRef(c.LongProp + ctx), 1L, (c, n) => c.LongProp == n.LongProp - 1L);
if (wasSet)
{
AssertAreEqual(prevValue.LongProp + 1L, CurrentValue.LongProp);
}
else
{
AssertAreNotEqual(prevValue.LongProp + 1L, CurrentValue.LongProp);
}
},
NumIterations
);
// (Func<T, T>, Func<T, T, TContext, bool>)
runner.ExecuteFreeThreadedTests(
target => {
var(wasSet, prevValue, CurrentValue) = target.TryExchange(c => new DummyImmutableRef(c.LongProp + 1L), (c, n, ctx) => c.LongProp == n.LongProp - ctx, 1L);
if (wasSet)
{
AssertAreEqual(prevValue.LongProp + 1L, CurrentValue.LongProp);
}
else
{
AssertAreNotEqual(prevValue.LongProp + 1L, CurrentValue.LongProp);
}
},
NumIterations
);
// (Func<T, TMapContext, T>, Func<T, T, TPredicateContext, bool>)
runner.ExecuteFreeThreadedTests(
target => {
var(wasSet, prevValue, CurrentValue) = target.TryExchange((c, ctx) => new DummyImmutableRef(c.LongProp + (ctx - 1L)), 2L, (c, n, ctx) => c.LongProp == n.LongProp - ctx, 1L);
if (wasSet)
{
AssertAreEqual(prevValue.LongProp + 1L, CurrentValue.LongProp);
}
else
{
AssertAreNotEqual(prevValue.LongProp + 1L, CurrentValue.LongProp);
}
},
NumIterations
);
}
public void Assert_Coherency_TrySet()
{
const int NumIterations = 1_000_000;
var runner = NewRunner(new DummyImmutableRef(0L));
runner.GlobalSetUp = (target, _) => target.Set(new DummyImmutableRef(0L));
// bool TrySet(T newValue, Func<T, bool> setPredicate);
runner.AllThreadsTearDown = target => {
FastAssertEqual(NumIterations, target.Value.LongProp);
};
runner.ExecuteContinuousCoherencyTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
var newValue = new DummyImmutableRef(curValue.LongProp + 1);
target.TrySet(newValue, v => v.LongProp + 1 == newValue.LongProp);
FastAssertTrue(target.Value.LongProp > curValue.LongProp);
}
},
target => target.Value,
(prev, cur) => {
FastAssertTrue(cur.LongProp >= prev.LongProp);
},
v => v.LongProp == NumIterations
);
runner.AllThreadsTearDown = null;
// bool TrySet(T newValue, Func<T, bool> setPredicate, out T previousValue);
runner.AllThreadsTearDown = target => {
FastAssertEqual(NumIterations, target.Value.LongProp);
};
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
var newValue = new DummyImmutableRef(curValue.LongProp + 1);
var wasSet = target.TrySet(newValue, v => v.LongProp + 1 == newValue.LongProp, out var prevValue);
if (wasSet)
{
FastAssertEqual(curValue, prevValue);
}
else
{
FastAssertNotEqual(curValue, prevValue);
}
}
}
);
runner.AllThreadsTearDown = null;
// bool TrySet(Func<T, T> valueMapFunc, Func<T, bool> setPredicate);
runner.AllThreadsTearDown = target => {
FastAssertEqual(NumIterations, target.Value.LongProp);
};
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
target.TrySet(v => new DummyImmutableRef(v.LongProp + 1), v => v == curValue);
FastAssertTrue(target.Value.LongProp > curValue.LongProp);
}
}
);
runner.AllThreadsTearDown = null;
// bool TrySet(Func<T, T> valueMapFunc, Func<T, bool> setPredicate, out T previousValue);
runner.AllThreadsTearDown = target => {
FastAssertEqual(NumIterations, target.Value.LongProp);
};
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
var wasSet = target.TrySet(v => new DummyImmutableRef(v.LongProp + 1), v => v == curValue, out var prevValue);
if (wasSet)
{
FastAssertEqual(curValue, prevValue);
}
else
{
FastAssertNotEqual(curValue, prevValue);
}
}
}
);
runner.AllThreadsTearDown = null;
// bool TrySet(Func<T, T> valueMapFunc, Func<T, bool> setPredicate, out T previousValue, out T newValue);
runner.AllThreadsTearDown = target => {
FastAssertEqual(NumIterations, target.Value.LongProp);
};
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
var wasSet = target.TrySet(v => new DummyImmutableRef(v.LongProp + 1), v => v == curValue, out var prevValue, out var newValue);
if (wasSet)
{
FastAssertEqual(curValue, prevValue);
FastAssertEqual(prevValue.LongProp + 1, newValue.LongProp);
}
else
{
FastAssertNotEqual(curValue, prevValue);
FastAssertEqual(prevValue, newValue);
}
}
}
);
runner.AllThreadsTearDown = null;
// bool TrySet(Func<T, T> valueMapFunc, Func<T, T, bool> setPredicate);
runner.AllThreadsTearDown = target => {
FastAssertEqual(NumIterations, target.Value.LongProp);
};
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
target.TrySet(v => new DummyImmutableRef(v.LongProp + 1), (c, n) => c.LongProp == curValue.LongProp && n.LongProp == c.LongProp + 1);
FastAssertTrue(target.Value.LongProp > curValue.LongProp);
}
}
);
runner.AllThreadsTearDown = null;
// bool TrySet(Func<T, T> valueMapFunc, Func<T, T, bool> setPredicate, out T previousValue);
runner.AllThreadsTearDown = target => {
FastAssertEqual(NumIterations, target.Value.LongProp);
};
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
var wasSet = target.TrySet(v => new DummyImmutableRef(v.LongProp + 1), (c, n) => c.LongProp == curValue.LongProp && n.LongProp == c.LongProp + 1, out var prevValue);
if (wasSet)
{
FastAssertEqual(curValue, prevValue);
}
else
{
FastAssertNotEqual(curValue, prevValue);
}
}
}
);
runner.AllThreadsTearDown = null;
// bool TrySet(Func<T, T> valueMapFunc, Func<T, T, bool> setPredicate, out T previousValue, out T newValue);
runner.AllThreadsTearDown = target => {
FastAssertEqual(NumIterations, target.Value.LongProp);
};
runner.ExecuteFreeThreadedTests(
target => {
while (true)
{
var curValue = target.Value;
if (curValue.LongProp == NumIterations)
{
return;
}
var wasSet = target.TrySet(v => new DummyImmutableRef(v.LongProp + 1), (c, n) => c.LongProp == curValue.LongProp && n.LongProp == c.LongProp + 1, out var prevValue, out var newValue);
if (wasSet)
{
FastAssertEqual(curValue, prevValue);
FastAssertEqual(prevValue.LongProp + 1, newValue.LongProp);
}
else
{
FastAssertNotEqual(curValue, prevValue);
FastAssertEqual(prevValue, newValue);
}
}
}
);
runner.AllThreadsTearDown = null;
}
