private bool ProcessActiveBlock(ManagedBufferBlock block, WaitHandle[] processEvents)
{
while (block.Active)
{
switch (WaitHandle.WaitAny(processEvents))
{
case 0:
_communicationManager.HandleCommunicationBlock(block.CommunicationBlock, b => { });
break;
case 1:
var data = _communicationManager.HandleMemoryBlock(block.MemoryBlock);
// don't let the queue get too big as using too much memory causes
// problems i.e. the target process closes down but the host takes
// ages to shutdown; this is a compromise.
_messageQueue.Enqueue(data);
if (_messageQueue.Count > 400)
{
do
{
ThreadHelper.YieldOrSleep(100);
} while (_messageQueue.Count > 200);
}
break;
default: // 2
return(true);
}
}
return(false);
}
private void StartProcessingThread(IManagedCommunicationBlock communicationBlock, IManagedMemoryBlock memoryBlock)
{
var threadActivated = new AutoResetEvent(false);
ThreadPool.QueueUserWorkItem((state) =>
{
var processEvents = new WaitHandle[]
{
communicationBlock.ProfilerRequestsInformation,
memoryBlock.ProfilerHasResults
};
threadActivated.Set();
do
{
switch (WaitHandle.WaitAny(processEvents, new TimeSpan(0, 0, 1)))
{
case WaitHandle.WaitTimeout:
break;
case 0:
_communicationManager.HandleCommunicationBlock(communicationBlock, (cB, mB) => { });
break;
case 1:
{
var data = _communicationManager.HandleMemoryBlock(memoryBlock);
_messageQueue.Enqueue(data);
}
break;
}
} while (_continueWait);
});
threadActivated.WaitOne();
}
private WaitCallback ProcessBlock(IManagedCommunicationBlock communicationBlock, IManagedMemoryBlock memoryBlock,
WaitHandle terminateThread, EventWaitHandle threadActivated, EventWaitHandle threadTerminated)
{
return(state =>
{
var processEvents = new WaitHandle[]
{
communicationBlock.ProfilerRequestsInformation,
memoryBlock.ProfilerHasResults,
terminateThread
};
threadActivated.Set();
while (true)
{
switch (WaitHandle.WaitAny(processEvents))
{
case 0:
_communicationManager.HandleCommunicationBlock(communicationBlock, (cB, mB) => { });
break;
case 1:
var data = _communicationManager.HandleMemoryBlock(memoryBlock);
_messageQueue.Enqueue(data);
break;
case 2:
threadTerminated.Set();
return;
}
}
});
}
private WaitCallback ProcessBlock(ManagedBufferBlock block,
EventWaitHandle threadActivatedEvent, ThreadTermination threadTermination)
{
return(state =>
{
try
{
var processEvents = new WaitHandle[]
{
block.CommunicationBlock.ProfilerRequestsInformation,
block.MemoryBlock.ProfilerHasResults,
threadTermination.CancelThreadEvent
};
threadActivatedEvent.Set();
try
{
while (block.Active)
{
switch (WaitHandle.WaitAny(processEvents))
{
case 0:
_communicationManager.HandleCommunicationBlock(block.CommunicationBlock, b => { });
break;
case 1:
var data = _communicationManager.HandleMemoryBlock(block.MemoryBlock);
// don't let the queue get too big as using too much memory causes
// problems i.e. the target process closes down but the host takes
// ages to shutdown; this is a compromise.
_messageQueue.Enqueue(data);
if (_messageQueue.Count > 400)
{
do
{
ThreadHelper.YieldOrSleep(100);
} while (_messageQueue.Count > 200);
}
break;
default: // 2
return;
}
}
_memoryManager.RemoveDeactivatedBlock(block);
}
finally
{
threadTermination.ThreadFinishedEvent.Set();
}
}
catch (ObjectDisposedException)
{
/* an attempt to close thread has probably happened and the events disposed */
}
});
}
private WaitCallback ProcessBlock(ManagedBufferBlock block,
WaitHandle terminateThread, EventWaitHandle threadActivated, EventWaitHandle threadTerminated)
{
return(state =>
{
var processEvents = new []
{
block.CommunicationBlock.ProfilerRequestsInformation,
block.MemoryBlock.ProfilerHasResults,
terminateThread
};
threadActivated.Set();
while (block.Active)
{
switch (WaitHandle.WaitAny(processEvents))
{
case 0:
_communicationManager.HandleCommunicationBlock(block.CommunicationBlock, b => { });
break;
case 1:
var data = _communicationManager.HandleMemoryBlock(block.MemoryBlock);
// don't let the queue get too big as using too much memory causes
// problems i.e. the target process closes down but the host takes
// ages to shutdown; this is a compromise.
_messageQueue.Enqueue(data);
if (_messageQueue.Count > 400)
{
do
{
Thread.Yield();
} while (_messageQueue.Count > 200);
}
break;
case 2:
threadTerminated.Set();
return;
}
}
threadTerminated.Set();
_memoryManager.RemoveDeactivatedBlocks();
});
}
private Tuple <ManualResetEvent, ManualResetEvent> StartProcessingThread(IManagedCommunicationBlock communicationBlock, IManagedMemoryBlock memoryBlock)
{
var threadActivated = new AutoResetEvent(false);
var terminateThread = new ManualResetEvent(false);
var threadTerminated = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem((state) =>
{
var processEvents = new WaitHandle[]
{
communicationBlock.ProfilerRequestsInformation,
memoryBlock.ProfilerHasResults,
terminateThread,
};
threadActivated.Set();
while (true)
{
switch (WaitHandle.WaitAny(processEvents))
{
case 0:
_communicationManager.HandleCommunicationBlock(communicationBlock, (cB, mB) => { });
break;
case 1:
{
var data = _communicationManager.HandleMemoryBlock(memoryBlock);
_messageQueue.Enqueue(data);
}
break;
case 2:
threadTerminated.Set();
return;
}
}
});
threadActivated.WaitOne();
return(new Tuple <ManualResetEvent, ManualResetEvent>(terminateThread, threadTerminated));
}