public void CreateAtomicValContext()
{
_atomicVal = new OptimisticallyLockedValue <Vector2>(new Vector2(-1f, -1f));
_atomicValBarrier = new ManualResetEvent(false);
_atomicValThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumThreads, _atomicValBarrier, WithAtomicVal_Entry, _atomicValThreads);
}
/** <inheritDoc /> */
protected override void OnStarted()
{
Emps = new Employee[Dataset];
for (var i = 0; i < Emps.Length; i++)
{
Emps[i] = BenchmarkUtils.GetRandomEmployee(Payload);
}
var cfg = new IgniteConfiguration
{
BinaryConfiguration = GetBinaryConfiguration(),
JvmOptions = new List <string>
{
"-Xms2g",
"-Xmx2g",
"-DIGNITE_QUIET=false",
"-DIGNITE_NO_SHUTDOWN_HOOK=true"
},
JvmClasspath = Classpath ?? Core.Impl.Common.Classpath.CreateClasspath(forceTestClasspath: true),
JvmDllPath = DllPath,
SpringConfigUrl = ConfigPath
};
Node = Ignition.Start(cfg);
}
void WithAtomicLong_Entry()
{
for (var i = 0; i < NumIterations; ++i)
{
_atomicLong.Decrement();
_atomicLong.Increment();
BenchmarkUtils.SimulateContention(ContentionLevel);
_atomicLong.Increment();
var curVal = _atomicLong.Value;
curVal = _atomicLong.Exchange(curVal * 2L).CurrentValue;
BenchmarkUtils.SimulateContention(ContentionLevel);
curVal = _atomicLong.TryExchange(curVal / 2L, curVal).CurrentValue;
var prevVal = _atomicLong.TryBoundedExchange(curVal + 10L, curVal - 3L, curVal + 3L).PreviousValue;
if (prevVal == curVal)
{
_atomicLong.Subtract(10L);
}
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
public void CreateAtomicLongContext()
{
_atomicLong = new AtomicLong(0L);
_atomicLongBarrier = new ManualResetEvent(false);
_atomicLongThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumThreads, _atomicLongBarrier, WithAtomicLong_Entry, _atomicLongThreads);
}
public void CreateAtomicValUnmanagedContext()
{
_atomicValUnmanaged = new AtomicValUnmanaged <Vector2>(new Vector2(-1f, -1f));
_atomicValUnmanagedBarrier = new ManualResetEvent(false);
_atomicValUnmanagedThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumThreads, _atomicValUnmanagedBarrier, WithAtomicValUnmanaged_Entry, _atomicValUnmanagedThreads);
}
/// <summary>
/// Cache GetAll.
/// </summary>
private void GetAll(BenchmarkState state)
{
var idx = BenchmarkUtils.GetRandomInt(Dataset - DatasetBatchSize);
var keys = Enumerable.Range(idx, DatasetBatchSize);
Cache.GetAll(keys);
}
public void CreateContextualFuncsContext()
{
_contextualFuncsBarrier = new ManualResetEvent(false);
_contextualFuncsThreads = new List <Thread>();
_contextualFuncsUser = new LockFreeReference <User>(new User(0, ""));
_contextualFuncsInt64 = new LockFreeInt64(0L);
BenchmarkUtils.PrepareThreads(NumThreads, _contextualFuncsBarrier, WithContextualFuncs_Entry, _contextualFuncsThreads);
}
public void CreateLockedLongContext()
{
_lockedLongLock = new object();
_lockedLong = new LockFreeInt64(0L);
_lockedLongBarrier = new ManualResetEvent(false);
_lockedLongThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumThreads, _lockedLongBarrier, WithLockedLong_Entry, _lockedLongThreads);
}
public void CreateLessGranularLockContext()
{
_lessGranularLock = new object();
_lessGranularLockVal = new Vector2(-1f, -1f);
_lessGranularLockBarrier = new ManualResetEvent(false);
_lessGranularLockThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumThreads, _lessGranularLockBarrier, WithLessGranularLock_Entry, _lessGranularLockThreads);
}
public void CreateContextualFuncsContext()
{
_contextualFuncsBarrier = new ManualResetEvent(false);
_contextualFuncsThreads = new List <Thread>();
_contextualFuncsUser = new AtomicRef <User>(new User(0, ""));
_contextualFuncsLong = new AtomicLong(0L);
BenchmarkUtils.PrepareThreads(NumThreads, _contextualFuncsBarrier, WithContextualFuncs_Entry, _contextualFuncsThreads);
}
public void CreateLockedLongLessGranularContext()
{
_lockedLessGranularLongLock = new object();
_lockedLessGranularLong = new AtomicLong(0L);
_lockedLessGranularLongBarrier = new ManualResetEvent(false);
_lockedLessGranularLongThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumThreads, _lockedLessGranularLongBarrier, WithLockedLongLessGranular_Entry, _lockedLessGranularLongThreads);
}
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);
}
}
public void CreateRWLSContext()
{
_rwls = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
_rwlsVal = new Vector2(-1f, -1f);
_rwlsBarrier = new ManualResetEvent(false);
_rwlsThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumThreads, _rwlsBarrier, WithRWLS_Entry, _rwlsThreads);
}
public void CreateAtomicValContext()
{
_atomicVal = new AtomicVal <Val64>(new Val64(-1L));
_atomicValBarrier = new ManualResetEvent(false);
_atomicValThreads = new List <Thread>();
_atomicValSyncBarrier = new Barrier(NumThreads);
BenchmarkUtils.PrepareThreads(NumThreads, _atomicValBarrier, WithAtomicVal_Entry, _atomicValThreads);
}
public void CreateManualLoopsContext()
{
_manualLoopsBarrier = new ManualResetEvent(false);
_manualLoopsThreads = new List <Thread>();
_manualLoopsUser = new AtomicRef <User>(new User(0, ""));
_manualLoopsLong = new AtomicLong(0L);
BenchmarkUtils.PrepareThreads(NumThreads, _manualLoopsBarrier, WithManualLoops_Entry, _manualLoopsThreads);
}
public void CreateAtomicRefContext()
{
_atomicUser = new LockFreeReference <User>(new User(0, _usernames[0]));
_atomicRefBarrier = new ManualResetEvent(false);
_atomicRefThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumWriters, _atomicRefBarrier, WithAtomicRef_WriterEntry, _atomicRefThreads);
BenchmarkUtils.PrepareThreads(NumReaders, _atomicRefBarrier, WithAtomicRef_ReaderEntry, _atomicRefThreads);
}
public void CreateRWLSContext()
{
_rwls = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
_rwlsUser = new User(0, _usernames[0]);
_rwlsBarrier = new ManualResetEvent(false);
_rwlsThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumWriters, _rwlsBarrier, WithRWLS_WriterEntry, _rwlsThreads);
BenchmarkUtils.PrepareThreads(NumReaders, _rwlsBarrier, WithRWLS_ReaderEntry, _rwlsThreads);
}
public void CreateStandardLockContext()
{
_lockObject = new object();
_standardLockUser = new User(0, _usernames[0]);
_standardLockBarrier = new ManualResetEvent(false);
_standardLockThreads = new List <Thread>();
BenchmarkUtils.PrepareThreads(NumWriters, _standardLockBarrier, WithStandardLock_WriterEntry, _standardLockThreads);
BenchmarkUtils.PrepareThreads(NumReaders, _standardLockBarrier, WithStandardLock_ReaderEntry, _standardLockThreads);
}
void WithAtomicRef_ReaderEntry()
{
for (var i = 0; i < NumIterations; ++i)
{
var curUser = _atomicUser.Value;
BenchmarkUtils.Assert(curUser.Name == _usernames[curUser.LoginID]);
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
public void CreateAtomicValContext()
{
_atomicVal = new LockFreeValue <Vector2>(new Vector2(5f, 10f));
_atomicValBarrier = new ManualResetEvent(false);
_atomicValThreads = new List <Thread>();
_atomicValRemainingThreadCount = new LockFreeInt32(NumThreads);
BenchmarkUtils.PrepareThreads(NumThreads, _atomicValBarrier, WithAtomicVal_EntryA, _atomicValThreads);
BenchmarkUtils.PrepareThreads(NumThreads, _atomicValBarrier, WithAtomicVal_EntryB, _atomicValThreads);
}
public void CreateManualLoopContext()
{
_manualLoopVector2 = new Vector2(5f, 10f);
_manualLoopBarrier = new ManualResetEvent(false);
_manualLoopThreads = new List <Thread>();
_manualLoopRemainingThreadCount = new LockFreeInt32(NumThreads);
BenchmarkUtils.PrepareThreads(NumThreads, _manualLoopBarrier, WithManualLoop_EntryA, _manualLoopThreads);
BenchmarkUtils.PrepareThreads(NumThreads, _manualLoopBarrier, WithManualLoop_EntryB, _manualLoopThreads);
}
public void CreateLockContext()
{
_lock = new object();
_lockVal = new Val64(-1L);
_lockBarrier = new ManualResetEvent(false);
_lockThreads = new List <Thread>();
_lockSyncBarrier = new Barrier(NumThreads);
BenchmarkUtils.PrepareThreads(NumThreads, _lockBarrier, WithLock_Entry, _lockThreads);
}
void WithStandardLock_ReaderEntry()
{
for (var i = 0; i < NumIterations; ++i)
{
User curUser;
lock (_lockObject) curUser = _standardLockUser;
BenchmarkUtils.Assert(curUser.Name == _usernames[curUser.LoginID]);
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
void WithAtomicVal_EntryA()
{
while (_atomicValRemainingThreadCount > 0)
{
var curVal = _atomicVal.Value;
_atomicVal.TryExchange(new Vector2(curVal.Y, curVal.X), curVal);
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
void WithManualLoop_EntryA()
{
while (_manualLoopRemainingThreadCount > 0)
{
var curVal = Interlocked.Read(ref _manualLoopVector2.L);
var curValAsVec = new Vector2(curVal);
Interlocked.CompareExchange(ref _manualLoopVector2.L, new Vector2(curValAsVec.Y, curValAsVec.X).L, curVal);
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
void WithStandardLock_WriterEntry()
{
for (var i = 0; i < NumIterations; ++i)
{
lock (_lockObject) {
var nextID = _standardLockUser.LoginID + 1;
_standardLockUser = new User(nextID, _usernames[nextID]);
}
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
void WithRWLS_WriterEntry()
{
for (var i = 0; i < NumIterations; ++i)
{
_rwls.EnterWriteLock();
var nextID = _rwlsUser.LoginID + 1;
_rwlsUser = new User(nextID, _usernames[nextID]);
_rwls.ExitWriteLock();
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
void WithRWLS_ReaderEntry()
{
for (var i = 0; i < NumIterations; ++i)
{
_rwls.EnterReadLock();
var curUser = _rwlsUser;
_rwls.ExitReadLock();
BenchmarkUtils.Assert(curUser.Name == _usernames[curUser.LoginID]);
BenchmarkUtils.SimulateContention(ContentionLevel);
}
}
/// <summary>
/// Cache put.
/// </summary>
private void PutTx(BenchmarkState state)
{
int idx = BenchmarkUtils.GetRandomInt(Dataset);
using (var tx = Node.GetTransactions().TxStart(TransactionConcurrency.Pessimistic,
TransactionIsolation.RepeatableRead))
{
_cache.Put(idx, Emps[idx]);
tx.Commit();
}
}
void WithAtomicVal_EntryB()
{
for (var i = 0; i < NumIterations; ++i)
{
var curVal = _atomicVal.Value;
_atomicVal.SpinWaitForValue(new Vector2(curVal.Y, curVal.X));
BenchmarkUtils.SimulateContention(ContentionLevel);
_atomicVal.SpinWaitForExchange(curVal, new Vector2(curVal.Y, curVal.X));
BenchmarkUtils.SimulateContention(ContentionLevel);
}
_atomicValRemainingThreadCount.Decrement();
}
