public void WithTupleReturns()
{
// These vars basically used to ensure the compiler doesn't optimise away the return values entirely
var longResultVar = 0L;
var intResultVar = 0;
var refResultVar = "";
var valResultVar = 0L;
for (var i = 0; i < NumIterations; ++i)
{
longResultVar += _atomicInt64.Increment().CurrentValue;
longResultVar += _atomicInt64.Decrement().CurrentValue;
longResultVar += _atomicInt64.Exchange(i).PreviousValue;
intResultVar += _atomicInt32.Increment().CurrentValue;
intResultVar += _atomicInt32.Decrement().CurrentValue;
intResultVar += _atomicInt32.TryExchange(i, i - 1).ValueWasSet ? 1 : 0;
var newUser = new User(i, "Xenoprimate");
refResultVar = _atomicRef.Exchange(newUser).PreviousValue.Name;
refResultVar = _atomicRef.TryExchange(new User(i * 2, "Ben"), newUser).ValueWasSet ? refResultVar : String.Empty;
valResultVar += _atomicVal8.Exchange(new Val8(i)).PreviousValue.A;
valResultVar += _atomicVal16.TryExchange(new Val16(i + 1), new Val16(i)).ValueWasSet ? 0 : 1;
valResultVar += _atomicVal32.Exchange(new Val32(i)).PreviousValue.A;
valResultVar += _atomicVal64.TryExchange(new Val64(i + 1), new Val64(i)).ValueWasSet ? 0 : 1;
SimulateContention(ContentionLevel);
}
if (longResultVar != 1499996500003L || intResultVar != -728379967 || !refResultVar.Equals("Ben", StringComparison.Ordinal) || valResultVar != 999997000002L)
{
throw new ApplicationException("This will never happen; it's just here to force the compiler not to optimise away these vars. These results were measured before.");
}
}
public void ChangeUserName(string newUsername)
{
// Atomically swap the _sessionUser for a new User object with the new username and same ID; then print out the old name
var previousName = _sessionUser.Exchange(u => new User(newUsername, u.ID)).PreviousValue.Name;
Console.WriteLine($"Session user '{previousName}' has changed name to {newUsername}.");
}
void WithAtomicRef_WriterEntry()
{
for (var i = 0; i < NumIterations; ++i)
{
_atomicUser.Exchange(cur => new User(cur.LoginID + 1, _usernames[cur.LoginID + 1]));
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
void WithClosureCapturingFuncs_Entry()
{
var usernameA = "aaaa";
var usernameB = "bbbb";
for (var i = 0; i < NumIterations; i++)
{
_closureCapturingFuncsUser.Exchange(u => new User(u.LoginID, (i & 1) == 0 ? usernameA : usernameB));
_closureCapturingFuncsUser.TryExchange(u => new User(u.LoginID, (i & 1) == 0 ? usernameA : usernameB), (cur, next) => cur.Name == usernameA || next.Name == usernameA);
_closureCapturingFuncsInt64.TryBoundedExchange(l => l + i, 0L, NumIterations);
_closureCapturingFuncsInt64.TryMinimumExchange(l => l + i, 0L);
_closureCapturingFuncsInt64.TryMaximumExchange(l => l + i, NumIterations);
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
void WithContextualFuncs_Entry()
{
var usernameA = "aaaa";
var usernameB = "bbbb";
for (var i = 0; i < NumIterations; i++)
{
_contextualFuncsUser.Exchange((u, ctx) => new User(u.LoginID, ctx), (i & 1) == 0 ? usernameA : usernameB);
_contextualFuncsUser.TryExchange((u, ctx) => new User(u.LoginID, ctx), (i & 1) == 0 ? usernameA : usernameB, (cur, next, ctx) => cur.Name == ctx || next.Name == ctx, usernameA);
_contextualFuncsInt64.TryBoundedExchange((l, ctx) => l + ctx, i, 0L, NumIterations);
_contextualFuncsInt64.TryMinimumExchange((l, ctx) => l + ctx, i, 0L);
_contextualFuncsInt64.TryMaximumExchange((l, ctx) => l + ctx, i, NumIterations);
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
