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)); }