public virtual void TestRandom()
{
DocumentsWriterStallControl ctrl = new DocumentsWriterStallControl();
ctrl.UpdateStalled(false);
ThreadClass[] stallThreads = new ThreadClass[AtLeast(3)];
for (int i = 0; i < stallThreads.Length; i++)
{
int stallProbability = 1 + Random().Next(10);
stallThreads[i] = new ThreadAnonymousInnerClassHelper(this, ctrl, stallProbability);
}
Start(stallThreads);
long time = DateTime.Now.Millisecond;
/*
* use a 100 sec timeout to make sure we not hang forever. join will fail in
* that case
*/
while ((DateTime.Now.Millisecond - time) < 100 * 1000 && !Terminated(stallThreads))
{
ctrl.UpdateStalled(false);
if (Random().NextBoolean())
{
Thread.@Yield();
}
else
{
Thread.Sleep(1);
}
}
Join(stallThreads);
}
public virtual void TestRandom()
{
DocumentsWriterStallControl ctrl = new DocumentsWriterStallControl();
ctrl.UpdateStalled(false);
ThreadJob[] stallThreads = new ThreadJob[AtLeast(3)];
for (int i = 0; i < stallThreads.Length; i++)
{
int stallProbability = 1 + Random.Next(10);
stallThreads[i] = new ThreadAnonymousClass(ctrl, stallProbability);
}
Start(stallThreads);
long time = J2N.Time.NanoTime() / J2N.Time.MillisecondsPerNanosecond; // LUCENENET: Use NanoTime() rather than CurrentTimeMilliseconds() for more accurate/reliable results
/*
* use a 100 sec timeout to make sure we not hang forever. join will fail in
* that case
*/
while (((J2N.Time.NanoTime() / J2N.Time.MillisecondsPerNanosecond) - time) < 100 * 1000 && !Terminated(stallThreads)) // LUCENENET: Use NanoTime() rather than CurrentTimeMilliseconds() for more accurate/reliable results
{
ctrl.UpdateStalled(false);
if (Random.NextBoolean())
{
Thread.Sleep(0);
}
else
{
Thread.Sleep(1);
}
}
Join(stallThreads);
}
public virtual void TestRandom()
{
DocumentsWriterStallControl ctrl = new DocumentsWriterStallControl();
ctrl.UpdateStalled(false);
ThreadClass[] stallThreads = new ThreadClass[AtLeast(3)];
for (int i = 0; i < stallThreads.Length; i++)
{
int stallProbability = 1 + Random().Next(10);
stallThreads[i] = new ThreadAnonymousInnerClassHelper(this, ctrl, stallProbability);
}
Start(stallThreads);
long time = DateTime.Now.Millisecond;
/*
* use a 100 sec timeout to make sure we not hang forever. join will fail in
* that case
*/
while ((DateTime.Now.Millisecond - time) < 100 * 1000 && !Terminated(stallThreads))
{
ctrl.UpdateStalled(false);
if (Random().NextBoolean())
{
Thread.@Yield();
}
else
{
Thread.Sleep(1);
}
}
Join(stallThreads);
}
public virtual void TestRandom()
{
DocumentsWriterStallControl ctrl = new DocumentsWriterStallControl();
ctrl.UpdateStalled(false);
ThreadJob[] stallThreads = new ThreadJob[AtLeast(3)];
for (int i = 0; i < stallThreads.Length; i++)
{
int stallProbability = 1 + Random.Next(10);
stallThreads[i] = new ThreadAnonymousClass(ctrl, stallProbability);
}
Start(stallThreads);
long time = Environment.TickCount;
/*
* use a 100 sec timeout to make sure we not hang forever. join will fail in
* that case
*/
while ((Environment.TickCount - time) < 100 * 1000 && !Terminated(stallThreads))
{
ctrl.UpdateStalled(false);
if (Random.NextBoolean())
{
Thread.Sleep(0);
}
else
{
Thread.Sleep(1);
}
}
Join(stallThreads);
}
public override void Run()
{
try
{
while (!stop)
{
int internalIters = release && Random.NextBoolean() ? AtLeast(5) : 1;
for (int i = 0; i < internalIters; i++)
{
ctrl.UpdateStalled(Random.NextBoolean());
}
if (checkPoint)
{
sync.updateJoin.Signal();
try
{
Assert.IsTrue(sync.await());
}
#if FEATURE_THREAD_INTERRUPT
catch (ThreadInterruptedException /*e*/)
{
Console.WriteLine("[Updater] got interrupted - wait count: " + sync.waiter.CurrentCount);
//throw new ThreadInterruptedException("Thread Interrupted Exception", e);
throw; // LUCENENET: CA2200: Rethrow to preserve stack details (https://docs.microsoft.com/en-us/visualstudio/code-quality/ca2200-rethrow-to-preserve-stack-details)
}
#endif
catch (Exception e)
{
Console.Write("signal failed with : " + e);
throw; // LUCENENET: CA2200: Rethrow to preserve stack details (https://docs.microsoft.com/en-us/visualstudio/code-quality/ca2200-rethrow-to-preserve-stack-details)
}
sync.leftCheckpoint.Signal();
}
if (Random.NextBoolean())
{
Thread.Sleep(0);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
exceptions.Add(e);
}
if (!sync.updateJoin.IsSet)
{
sync.updateJoin.Signal();
}
}
public override void Run()
{
try
{
while (!stop)
{
int internalIters = release && Random.NextBoolean() ? AtLeast(5) : 1;
for (int i = 0; i < internalIters; i++)
{
ctrl.UpdateStalled(Random.NextBoolean());
}
if (checkPoint)
{
sync.updateJoin.Signal();
try
{
Assert.IsTrue(sync.Await());
}
catch (Exception e) when(e.IsInterruptedException())
{
Console.WriteLine("[Updater] got interrupted - wait count: " + sync.waiter.CurrentCount);
throw new Util.ThreadInterruptedException(e);
}
// LUCENENET: Not sure why this catch block was added, but I suspect it was for debugging purposes. Commented it rather than removing it because
// there may be some value to debugging this way.
//catch (Exception e)
//{
// Console.Write("signal failed with : " + e);
// throw; // LUCENENET: CA2200: Rethrow to preserve stack details (https://docs.microsoft.com/en-us/visualstudio/code-quality/ca2200-rethrow-to-preserve-stack-details)
//}
sync.leftCheckpoint.Signal();
}
if (Random.NextBoolean())
{
Thread.Yield();
}
}
}
catch (Exception e) when(e.IsThrowable())
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
exceptions.Add(e);
}
// LUCENENET specific - possible InvalidOperationException here if Signal() is called more than what is required to decrement to zero
if (!sync.updateJoin.IsSet)
{
sync.updateJoin.Signal();
}
}
public virtual void TestSimpleStall()
{
DocumentsWriterStallControl ctrl = new DocumentsWriterStallControl();
ctrl.UpdateStalled(false);
ThreadClass[] waitThreads = WaitThreads(AtLeast(1), ctrl);
Start(waitThreads);
Assert.IsFalse(ctrl.HasBlocked());
Assert.IsFalse(ctrl.AnyStalledThreads());
Join(waitThreads);
// now stall threads and wake them up again
ctrl.UpdateStalled(true);
waitThreads = WaitThreads(AtLeast(1), ctrl);
Start(waitThreads);
AwaitState(ThreadState.WaitSleepJoin, waitThreads);
Assert.IsTrue(ctrl.HasBlocked());
Assert.IsTrue(ctrl.AnyStalledThreads());
ctrl.UpdateStalled(false);
Assert.IsFalse(ctrl.AnyStalledThreads());
Join(waitThreads);
}
public override void Run()
{
int iters = AtLeast(1000);
for (int j = 0; j < iters; j++)
{
Ctrl.UpdateStalled(Random().Next(StallProbability) == 0);
if (Random().Next(5) == 0) // thread 0 only updates
{
Ctrl.WaitIfStalled();
}
}
}
public virtual void TestSimpleStall()
{
DocumentsWriterStallControl ctrl = new DocumentsWriterStallControl();
ctrl.UpdateStalled(false);
ThreadClass[] waitThreads = WaitThreads(AtLeast(1), ctrl);
Start(waitThreads);
Assert.IsFalse(ctrl.HasBlocked());
Assert.IsFalse(ctrl.AnyStalledThreads());
Join(waitThreads);
// now stall threads and wake them up again
ctrl.UpdateStalled(true);
waitThreads = WaitThreads(AtLeast(1), ctrl);
Start(waitThreads);
AwaitState(ThreadState.WaitSleepJoin, waitThreads);
Assert.IsTrue(ctrl.HasBlocked());
Assert.IsTrue(ctrl.AnyStalledThreads());
ctrl.UpdateStalled(false);
Assert.IsFalse(ctrl.AnyStalledThreads());
Join(waitThreads);
}
public override void Run()
{
try
{
while (!Stop.Get())
{
int internalIters = Release && Random().NextBoolean() ? AtLeast(5) : 1;
for (int i = 0; i < internalIters; i++)
{
Ctrl.UpdateStalled(Random().NextBoolean());
}
if (CheckPoint.Get())
{
Sync.UpdateJoin.Signal();
try
{
Assert.IsTrue(Sync.await());
}
#if !NETSTANDARD
catch (ThreadInterruptedException e)
{
Console.WriteLine("[Updater] got interrupted - wait count: " + Sync.Waiter.CurrentCount);
throw new ThreadInterruptedException("Thread Interrupted Exception", e);
}
#endif
catch (Exception e)
{
Console.Write("signal failed with : " + e);
throw e;
}
Sync.LeftCheckpoint.Signal();
}
if (Random().NextBoolean())
{
Thread.Sleep(0);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
Exceptions.Add(e);
}
if (!Sync.UpdateJoin.IsSet)
{
Sync.UpdateJoin.Signal();
}
}
private bool UpdateStallState()
{
//Debug.Assert(Thread.holdsLock(this));
long limit = StallLimitBytes;
/*
* we block indexing threads if net byte grows due to slow flushes
* yet, for small ram buffers and large documents we can easily
* reach the limit without any ongoing flushes. we need to ensure
* that we don't stall/block if an ongoing or pending flush can
* not free up enough memory to release the stall lock.
*/
bool stall = ((activeBytes + flushBytes) > limit) && (activeBytes < limit) && !closed;
stallControl.UpdateStalled(stall);
return(stall);
}
public override void Run()
{
try
{
while (!Stop.Get())
{
int internalIters = Release && Random().NextBoolean() ? AtLeast(5) : 1;
for (int i = 0; i < internalIters; i++)
{
Ctrl.UpdateStalled(Random().NextBoolean());
}
if (CheckPoint.Get())
{
Sync.UpdateJoin.countDown();
try
{
Assert.IsTrue(Sync.@await());
}
catch (ThreadInterruptedException e)
{
Console.WriteLine("[Updater] got interrupted - wait count: " + Sync.Waiter.Remaining);
throw new ThreadInterruptedException(e);
}
Sync.LeftCheckpoint.countDown();
}
if (Random().NextBoolean())
{
Thread.@Yield();
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
Exceptions.Add(e);
}
Sync.UpdateJoin.countDown();
}
public virtual void TestAccquireReleaseRace()
{
DocumentsWriterStallControl ctrl = new DocumentsWriterStallControl();
ctrl.UpdateStalled(false);
AtomicBoolean stop = new AtomicBoolean(false);
AtomicBoolean checkPoint = new AtomicBoolean(true);
int numStallers = AtLeast(1);
int numReleasers = AtLeast(1);
int numWaiters = AtLeast(1);
var sync = new Synchronizer(numStallers + numReleasers, numStallers + numReleasers + numWaiters);
var threads = new ThreadClass[numReleasers + numStallers + numWaiters];
IList <Exception> exceptions = new SynchronizedCollection <Exception>();
for (int i = 0; i < numReleasers; i++)
{
threads[i] = new Updater(stop, checkPoint, ctrl, sync, true, exceptions);
}
for (int i = numReleasers; i < numReleasers + numStallers; i++)
{
threads[i] = new Updater(stop, checkPoint, ctrl, sync, false, exceptions);
}
for (int i = numReleasers + numStallers; i < numReleasers + numStallers + numWaiters; i++)
{
threads[i] = new Waiter(stop, checkPoint, ctrl, sync, exceptions);
}
Start(threads);
int iters = AtLeast(10000);
float checkPointProbability = TEST_NIGHTLY ? 0.5f : 0.1f;
for (int i = 0; i < iters; i++)
{
if (checkPoint.Get())
{
Assert.IsTrue(sync.UpdateJoin.@await(new TimeSpan(0, 0, 0, 10)), "timed out waiting for update threads - deadlock?");
if (exceptions.Count > 0)
{
foreach (Exception throwable in exceptions)
{
Console.WriteLine(throwable.ToString());
Console.Write(throwable.StackTrace);
}
Assert.Fail("got exceptions in threads");
}
if (ctrl.HasBlocked() && ctrl.Healthy)
{
AssertState(numReleasers, numStallers, numWaiters, threads, ctrl);
}
checkPoint.Set(false);
sync.Waiter.countDown();
sync.LeftCheckpoint.@await();
}
Assert.IsFalse(checkPoint.Get());
Assert.AreEqual(0, sync.Waiter.Remaining);
if (checkPointProbability >= (float)Random().NextDouble())
{
sync.Reset(numStallers + numReleasers, numStallers + numReleasers + numWaiters);
checkPoint.Set(true);
}
}
if (!checkPoint.Get())
{
sync.Reset(numStallers + numReleasers, numStallers + numReleasers + numWaiters);
checkPoint.Set(true);
}
Assert.IsTrue(sync.UpdateJoin.@await(new TimeSpan(0, 0, 0, 10)));
AssertState(numReleasers, numStallers, numWaiters, threads, ctrl);
checkPoint.Set(false);
stop.Set(true);
sync.Waiter.countDown();
sync.LeftCheckpoint.@await();
for (int i = 0; i < threads.Length; i++)
{
ctrl.UpdateStalled(false);
threads[i].Join(2000);
if (threads[i].IsAlive && threads[i] is Waiter)
{
if (threads[i].State == ThreadState.WaitSleepJoin)
{
Assert.Fail("waiter is not released - anyThreadsStalled: " + ctrl.AnyStalledThreads());
}
}
}
}
public virtual void TestAccquireReleaseRace()
{
DocumentsWriterStallControl ctrl = new DocumentsWriterStallControl();
ctrl.UpdateStalled(false);
AtomicBoolean stop = new AtomicBoolean(false);
AtomicBoolean checkPoint = new AtomicBoolean(true);
int numStallers = AtLeast(1);
int numReleasers = AtLeast(1);
int numWaiters = AtLeast(1);
var sync = new Synchronizer(numStallers + numReleasers, numStallers + numReleasers + numWaiters);
var threads = new ThreadClass[numReleasers + numStallers + numWaiters];
IList<Exception> exceptions = new SynchronizedCollection<Exception>();
for (int i = 0; i < numReleasers; i++)
{
threads[i] = new Updater(stop, checkPoint, ctrl, sync, true, exceptions);
}
for (int i = numReleasers; i < numReleasers + numStallers; i++)
{
threads[i] = new Updater(stop, checkPoint, ctrl, sync, false, exceptions);
}
for (int i = numReleasers + numStallers; i < numReleasers + numStallers + numWaiters; i++)
{
threads[i] = new Waiter(stop, checkPoint, ctrl, sync, exceptions);
}
Start(threads);
int iters = AtLeast(10000);
float checkPointProbability = TEST_NIGHTLY ? 0.5f : 0.1f;
for (int i = 0; i < iters; i++)
{
if (checkPoint.Get())
{
Assert.IsTrue(sync.UpdateJoin.@await(new TimeSpan(0, 0, 0, 10)), "timed out waiting for update threads - deadlock?");
if (exceptions.Count > 0)
{
foreach (Exception throwable in exceptions)
{
Console.WriteLine(throwable.ToString());
Console.Write(throwable.StackTrace);
}
Assert.Fail("got exceptions in threads");
}
if (ctrl.HasBlocked() && ctrl.Healthy)
{
AssertState(numReleasers, numStallers, numWaiters, threads, ctrl);
}
checkPoint.Set(false);
sync.Waiter.countDown();
sync.LeftCheckpoint.@await();
}
Assert.IsFalse(checkPoint.Get());
Assert.AreEqual(0, sync.Waiter.Remaining);
if (checkPointProbability >= (float)Random().NextDouble())
{
sync.Reset(numStallers + numReleasers, numStallers + numReleasers + numWaiters);
checkPoint.Set(true);
}
}
if (!checkPoint.Get())
{
sync.Reset(numStallers + numReleasers, numStallers + numReleasers + numWaiters);
checkPoint.Set(true);
}
Assert.IsTrue(sync.UpdateJoin.@await(new TimeSpan(0, 0, 0, 10)));
AssertState(numReleasers, numStallers, numWaiters, threads, ctrl);
checkPoint.Set(false);
stop.Set(true);
sync.Waiter.countDown();
sync.LeftCheckpoint.@await();
for (int i = 0; i < threads.Length; i++)
{
ctrl.UpdateStalled(false);
threads[i].Join(2000);
if (threads[i].IsAlive && threads[i] is Waiter)
{
if (threads[i].State == ThreadState.WaitSleepJoin)
{
Assert.Fail("waiter is not released - anyThreadsStalled: " + ctrl.AnyStalledThreads());
}
}
}
}
public virtual void TestAccquireReleaseRace()
{
DocumentsWriterStallControl ctrl = new DocumentsWriterStallControl();
ctrl.UpdateStalled(false);
AtomicBoolean stop = new AtomicBoolean(false);
AtomicBoolean checkPoint = new AtomicBoolean(true);
int numStallers = AtLeast(1);
int numReleasers = AtLeast(1);
int numWaiters = AtLeast(1);
var sync = new Synchronizer(numStallers + numReleasers, numStallers + numReleasers + numWaiters);
var threads = new ThreadJob[numReleasers + numStallers + numWaiters];
IList <Exception> exceptions = new SynchronizedList <Exception>();
for (int i = 0; i < numReleasers; i++)
{
threads[i] = new Updater(stop, checkPoint, ctrl, sync, true, exceptions);
}
for (int i = numReleasers; i < numReleasers + numStallers; i++)
{
threads[i] = new Updater(stop, checkPoint, ctrl, sync, false, exceptions);
}
for (int i = numReleasers + numStallers; i < numReleasers + numStallers + numWaiters; i++)
{
threads[i] = new Waiter(stop, checkPoint, ctrl, sync, exceptions);
}
Start(threads);
int iters = AtLeast(10000);
//float checkPointProbability = TestNightly ? 0.5f : 0.1f;
// LUCENENET specific - reduced probabliltiy on x86 to prevent it from timing out.
float checkPointProbability = TestNightly ? (Lucene.Net.Util.Constants.RUNTIME_IS_64BIT ? 0.5f : 0.25f) : 0.1f;
for (int i = 0; i < iters; i++)
{
if (checkPoint)
{
Assert.IsTrue(sync.updateJoin.Wait(TimeSpan.FromSeconds(10)), "timed out waiting for update threads - deadlock?");
if (exceptions.Count > 0)
{
foreach (Exception throwable in exceptions)
{
Console.WriteLine(throwable.ToString());
Console.Write(throwable.StackTrace);
}
Assert.Fail("got exceptions in threads");
}
if (ctrl.HasBlocked && ctrl.IsHealthy)
{
AssertState(numReleasers, numStallers, numWaiters, threads, ctrl);
}
checkPoint.Value = (false);
sync.waiter.Signal();
sync.leftCheckpoint.Wait();
}
Assert.IsFalse(checkPoint);
Assert.AreEqual(0, sync.waiter.CurrentCount);
if (checkPointProbability >= (float)Random.NextDouble())
{
sync.Reset(numStallers + numReleasers, numStallers + numReleasers + numWaiters);
checkPoint.Value = (true);
}
}
if (!checkPoint)
{
sync.Reset(numStallers + numReleasers, numStallers + numReleasers + numWaiters);
checkPoint.Value = (true);
}
Assert.IsTrue(sync.updateJoin.Wait(new TimeSpan(0, 0, 0, 10)));
AssertState(numReleasers, numStallers, numWaiters, threads, ctrl);
checkPoint.Value = (false);
stop.Value = (true);
sync.waiter.Signal();
sync.leftCheckpoint.Wait();
for (int i = 0; i < threads.Length; i++)
{
ctrl.UpdateStalled(false);
threads[i].Join(2000);
if (threads[i].IsAlive && threads[i] is Waiter)
{
if (threads[i].State == ThreadState.WaitSleepJoin)
{
Assert.Fail("waiter is not released - anyThreadsStalled: " + ctrl.AnyStalledThreads());
}
}
}
}