public void MasterWaitOnExternalLock(object lockObj, Func <bool> completionPredicate)
{
Assure.NotNull(lockObj);
Assure.NotNull(completionPredicate);
Assure.True(Monitor.IsEntered(lockObj));
Assure.Equal(Thread.CurrentThread, LosgapSystem.MasterThread);
Monitor.Enter(externalLockObjLock);
externalLockObj = lockObj;
try {
while (!completionPredicate())
{
while (masterInvocationQueue.Count > 0)
{
PipelineMasterInvocation pmi;
if (!masterInvocationQueue.TryDequeue(out pmi))
{
continue;
}
try {
if (pmi.IsSynchronousCall)
{
Monitor.Enter(pmi.InvocationCompleteMonitor);
pmi.Action();
}
else
{
pmi.Action();
}
}
catch (Exception e) {
if (pmi.IsSynchronousCall)
{
pmi.RaisedException = e;
}
else
{
LosgapSystem.ExitWithError("Exception raised in asynchronous pipeline master invocation.", e);
}
}
finally {
if (pmi.IsSynchronousCall)
{
Monitor.Pulse(pmi.InvocationCompleteMonitor);
Monitor.Exit(pmi.InvocationCompleteMonitor);
}
}
}
Monitor.Exit(externalLockObjLock);
Monitor.Wait(lockObj);
Monitor.Enter(externalLockObjLock);
}
}
finally {
externalLockObj = null;
Monitor.Exit(externalLockObjLock);
}
}
public static void ShutdownTests()
{
bool exited = false;
LosgapSystem.SystemExited += () => exited = true;
LosgapSystem.Exit();
SpinWait.SpinUntil(() => exited);
if (((TestLoggingProvider)Logger.LoggingProvider).SuppressionActive)
{
LosgapSystem.ExitWithError("Logging provider was still suppressed at test finish.");
}
}
public void MasterWaitForClose()
{
Assure.Equal(Thread.CurrentThread, LosgapSystem.MasterThread);
Monitor.Enter(barrierOpenLock);
hydrateInvocationQueue:
while (masterInvocationQueue.Count > 0)
{
PipelineMasterInvocation pmi;
if (!masterInvocationQueue.TryDequeue(out pmi))
{
continue;
}
try {
if (pmi.IsSynchronousCall)
{
Monitor.Enter(pmi.InvocationCompleteMonitor);
pmi.Action();
}
else
{
pmi.Action();
}
}
catch (Exception e) {
if (pmi.IsSynchronousCall)
{
pmi.RaisedException = e;
}
else
{
LosgapSystem.ExitWithError("Exception raised in asynchronous pipeline master invocation.", e);
}
}
finally {
if (pmi.IsSynchronousCall)
{
Monitor.Pulse(pmi.InvocationCompleteMonitor);
Monitor.Exit(pmi.InvocationCompleteMonitor);
}
}
}
if (barrierOpen)
{
Monitor.Wait(barrierOpenLock);
goto hydrateInvocationQueue;
}
Monitor.Exit(barrierOpenLock);
}
private void StartSlave()
{
try {
WorkBarrier.SlaveWaitForFirstOpen();
while (!isDisposed)
{
if (currentWorkIsInvokeAllAction)
{
currentInvokeAllAction();
}
else
{
for (int blockIndex = Interlocked.Decrement(ref numReservableBlocks);
blockIndex >= 0;
blockIndex = Interlocked.Decrement(ref numReservableBlocks))
{
int blockStartInc = currentBlockSize * blockIndex;
int blockEndEx = currentBlockSize * (blockIndex + 1);
for (int i = blockStartInc; i < blockEndEx; ++i)
{
currentAction(i);
}
}
}
WorkBarrier.SlaveWaitForReset();
}
Monitor.Enter(slaveThreadExitMonitor);
if (--numSlavesStillRunning == 0)
{
Monitor.Pulse(slaveThreadExitMonitor);
}
Monitor.Exit(slaveThreadExitMonitor);
Logger.Debug("Slave thread " + Thread.CurrentThread.Name + " has exited normally.");
}
catch (ThreadAbortException) {
Thread.ResetAbort();
}
catch (Exception e) {
LosgapSystem.ExitWithError("Slave thread encounted an unhandled exception.", e);
}
}
public void InvokeOnMaster(PipelineMasterInvocation pmi)
{
if (isDisposed)
{
throw new ObjectDisposedException("Can not invoke actions on master when pipeline is disposed!");
}
if (Thread.CurrentThread == LosgapSystem.MasterThread)
{
try {
pmi.Action();
}
catch (Exception e) {
if (pmi.IsSynchronousCall)
{
pmi.RaisedException = e;
}
else
{
LosgapSystem.ExitWithError("Exception raised in asynchronous pipeline master invocation.", e);
}
}
}
else
{
if (pmi.IsSynchronousCall)
{
Monitor.Enter(pmi.InvocationCompleteMonitor);
ParallelizationProvider.SlaveQueueOnMaster(pmi);
Monitor.Wait(pmi.InvocationCompleteMonitor);
Monitor.Exit(pmi.InvocationCompleteMonitor);
}
else
{
ParallelizationProvider.SlaveQueueOnMaster(pmi);
}
}
}
