//-----------------------------------------------------------------------------------
// The slow path used when a quick loop through the channels didn't come up
// with anything. We may need to block and/or mark channels as done.
//
private bool MoveNextSlowPath()
{
int doneChannels = 0;
// Remember the first channel we are looking at. If we pass through all of the
// channels without finding an element, we will go to sleep.
int firstChannelIndex = _channelIndex;
int currChannelIndex;
while ((currChannelIndex = _channelIndex) != _channels.Length)
{
AsynchronousChannel <T> current = _channels[currChannelIndex];
bool isDone = _done[currChannelIndex];
if (!isDone && current.TryDequeue(ref _currentElement !)) // TODO-NULLABLE: https://github.com/dotnet/csharplang/issues/2872
{
// The channel has an item to be processed. We already remembered the current
// element (Dequeue stores it as an out-parameter), so we just return true
// after advancing to the next channel.
_channelIndex = (currChannelIndex + 1) % _channels.Length;
return(true);
}
else
{
// There isn't an element in the current channel. Check whether the channel
// is done before possibly waiting for an element to arrive.
if (!isDone && current.IsDone)
{
// We must check to ensure an item didn't get enqueued after originally
// trying to dequeue above and reading the IsDone flag. If there are still
// elements, the producer may have marked the channel as done but of course
// we still need to continue processing them.
if (!current.IsChunkBufferEmpty)
{
bool dequeueResult = current.TryDequeue(ref _currentElement !); // TODO-NULLABLE: https://github.com/dotnet/csharplang/issues/2872
Debug.Assert(dequeueResult, "channel isn't empty, yet the dequeue failed, hmm");
return(true);
}
// Mark this channel as being truly done. We won't consider it any longer.
_done[currChannelIndex] = true;
isDone = true;
current.Dispose();
}
if (isDone)
{
Debug.Assert(_channels[currChannelIndex].IsDone, "thought this channel was done");
Debug.Assert(_channels[currChannelIndex].IsChunkBufferEmpty, "thought this channel was empty");
// Increment the count of done channels that we've seen. If this reaches the
// total number of channels, we know we're finally done.
if (++doneChannels == _channels.Length)
{
// Remember that we are done by setting the index past the end.
_channelIndex = currChannelIndex = _channels.Length;
break;
}
}
// Still no element. Advance to the next channel and continue searching.
_channelIndex = currChannelIndex = (currChannelIndex + 1) % _channels.Length;
// If the channels aren't done, and we've inspected all of the queues and still
// haven't found anything, we will go ahead and wait on all the queues.
if (currChannelIndex == firstChannelIndex)
{
// On our first pass through the queues, we didn't have any side-effects
// that would let a producer know we are waiting. Now we go through and
// accumulate a set of events to wait on.
try
{
// Reset our done channels counter; we need to tally them again during the
// second pass through.
doneChannels = 0;
for (int i = 0; i < _channels.Length; i++)
{
bool channelIsDone = false;
if (!_done[i] && _channels[i].TryDequeue(ref _currentElement !, ref channelIsDone)) // TODO-NULLABLE: https://github.com/dotnet/csharplang/issues/2872
{
// The channel has received an item since the last time we checked.
// Just return and let the consumer process the element returned.
return(true);
}
else if (channelIsDone)
{
if (!_done[i])
{
_done[i] = true;
}
if (++doneChannels == _channels.Length)
{
// No need to wait. All channels are done. Remember this by setting
// the index past the end of the channel list.
_channelIndex = currChannelIndex = _channels.Length;
break;
}
}
}
// If all channels are done, we can break out of the loop entirely.
if (currChannelIndex == _channels.Length)
{
break;
}
Debug.Assert(_consumerEvent != null);
//This Wait() does not require cancellation support as it will wake up when all the producers into the
//channel have finished. Hence, if all the producers wake up on cancellation, so will this.
_consumerEvent.Wait();
_channelIndex = currChannelIndex = _consumerEvent.Value;
_consumerEvent.Reset();
//
// We have woken up, and the channel that caused this is contained in the
// returned index. This could be due to one of two reasons. Either the channel's
// producer has notified that it is done, in which case we just have to take it
// out of our current wait-list and redo the wait, or a channel actually has an
// item which we will go ahead and process.
//
// We just go back 'round the loop to accomplish this logic. Reset the channel
// index and # of done channels. Go back to the beginning, starting with the channel
// that caused us to wake up.
//
firstChannelIndex = currChannelIndex;
doneChannels = 0;
}
//-----------------------------------------------------------------------------------
// The slow path used when a quick loop through the channels didn't come up
// with anything. We may need to block and/or mark channels as done.
//
private bool MoveNextSlowPath()
{
int doneChannels = 0;
// Remember the first channel we are looking at. If we pass through all of the
// channels without finding an element, we will go to sleep.
int firstChannelIndex = m_channelIndex;
int currChannelIndex;
while ((currChannelIndex = m_channelIndex) != m_channels.Length)
{
AsynchronousChannel <T> current = m_channels[currChannelIndex];
bool isDone = m_done[currChannelIndex];
if (!isDone && current.TryDequeue(ref m_currentElement))
{
// The channel has an item to be processed. We already remembered the current
// element (Dequeue stores it as an out-parameter), so we just return true
// after advancing to the next channel.
m_channelIndex = (currChannelIndex + 1) % m_channels.Length;
return(true);
}
else
{
// There isn't an element in the current channel. Check whether the channel
// is done before possibly waiting for an element to arrive.
if (!isDone && current.IsDone)
{
// We must check to ensure an item didn't get enqueued after originally
// trying to dequeue above and reading the IsDone flag. If there are still
// elements, the producer may have marked the channel as done but of course
// we still need to continue processing them.
if (!current.IsChunkBufferEmpty)
{
bool dequeueResult = current.TryDequeue(ref m_currentElement);
Contract.Assert(dequeueResult, "channel isn't empty, yet the dequeue failed, hmm");
return(true);
}
// Mark this channel as being truly done. We won't consider it any longer.
m_done[currChannelIndex] = true;
if (m_channelEvents != null)
{
m_channelEvents[currChannelIndex] = null; //we definitely never want to wait on this (soon to be disposed) event.
}
isDone = true;
current.Dispose();
}
if (isDone)
{
Contract.Assert(m_channels[currChannelIndex].IsDone, "thought this channel was done");
Contract.Assert(m_channels[currChannelIndex].IsChunkBufferEmpty, "thought this channel was empty");
// Increment the count of done channels that we've seen. If this reaches the
// total number of channels, we know we're finally done.
if (++doneChannels == m_channels.Length)
{
// Remember that we are done by setting the index past the end.
m_channelIndex = currChannelIndex = m_channels.Length;
break;
}
}
// Still no element. Advance to the next channel and continue searching.
m_channelIndex = currChannelIndex = (currChannelIndex + 1) % m_channels.Length;
// If the channels aren't done, and we've inspected all of the queues and still
// haven't found anything, we will go ahead and wait on all the queues.
if (currChannelIndex == firstChannelIndex)
{
// On our first pass through the queues, we didn't have any side-effects
// that would let a producer know we are waiting. Now we go through and
// accumulate a set of events to wait on.
try
{
// If this is the first time we must block, lazily allocate and cache
// a list of events to be reused for next time.
if (m_channelEvents == null)
{
m_channelEvents = new ManualResetEventSlim[m_channels.Length];
}
// Reset our done channels counter; we need to tally them again during the
// second pass through.
doneChannels = 0;
for (int i = 0; i < m_channels.Length; i++)
{
if (!m_done[i] && m_channels[i].TryDequeue(ref m_currentElement, ref m_channelEvents[i]))
{
Contract.Assert(m_channelEvents[i] == null);
// The channel has received an item since the last time we checked.
// Just return and let the consumer process the element returned.
return(true);
}
else if (m_channelEvents[i] == null)
{
// The channel in question is done and empty.
Contract.Assert(m_channels[i].IsDone, "expected channel to be done");
Contract.Assert(m_channels[i].IsChunkBufferEmpty, "expected channel to be empty");
if (!m_done[i])
{
m_done[i] = true;
m_channels[i].Dispose();
}
if (++doneChannels == m_channels.Length)
{
// No need to wait. All channels are done. Remember this by setting
// the index past the end of the channel list.
m_channelIndex = currChannelIndex = m_channels.Length;
break;
}
}
}
// If all channels are done, we can break out of the loop entirely.
if (currChannelIndex == m_channels.Length)
{
break;
}
// Finally, we have accumulated a set of events. Perform a wait-any on them.
Contract.Assert(m_channelEvents.Length <= 63,
"WaitForMultipleObjects only supports 63 threads if running on an STA thread (64 otherwise).");
//This WaitAny() does not require cancellation support as it will wake up when all the producers into the
//channel have finished. Hence, if all the producers wake up on cancellation, so will this.
m_channelIndex = currChannelIndex = WaitAny(m_channelEvents);
Contract.Assert(0 <= m_channelIndex && m_channelIndex < m_channelEvents.Length);
Contract.Assert(0 <= currChannelIndex && currChannelIndex < m_channelEvents.Length);
Contract.Assert(m_channelEvents[currChannelIndex] != null);
//
// We have woken up, and the channel that caused this is contained in the
// returned index. This could be due to one of two reasons. Either the channel's
// producer has notified that it is done, in which case we just have to take it
// out of our current wait-list and redo the wait, or a channel actually has an
// item which we will go ahead and process.
//
// We just go back 'round the loop to accomplish this logic. Reset the channel
// index and # of done channels. Go back to the beginning, starting with the channel
// that caused us to wake up.
//
firstChannelIndex = currChannelIndex;
doneChannels = 0;
}
finally
{
// We have to guarantee that any waits we said we would perform are undone.
for (int i = 0; i < m_channelEvents.Length; i++)
{
// If we retrieved an event from a channel, we need to reset the wait.
if (m_channelEvents[i] != null)
{
m_channels[i].DoneWithDequeueWait();
}
}
}
}
}
}
TraceHelpers.TraceInfo("[timing]: {0}: Completed the merge", DateTime.Now.Ticks);
// If we got this far, it means we've exhausted our channels.
Contract.Assert(currChannelIndex == m_channels.Length);
// If any tasks failed, propagate the failure now. We must do it here, because the merge
// executor returns control back to the caller before the query has completed; contrast
// this with synchronous enumeration where we can wait before returning.
m_taskGroupState.QueryEnd(false);
return(false);
}
private bool MoveNextSlowPath()
{
int num3;
int num = 0;
int channelIndex = this.m_channelIndex;
while ((num3 = this.m_channelIndex) != this.m_channels.Length)
{
AsynchronousChannel <T> channel = this.m_channels[num3];
bool flag = this.m_done[num3];
if (!flag && channel.TryDequeue(ref this.m_currentElement))
{
this.m_channelIndex = (num3 + 1) % this.m_channels.Length;
return(true);
}
if (!flag && channel.IsDone)
{
if (!channel.IsChunkBufferEmpty)
{
channel.TryDequeue(ref this.m_currentElement);
return(true);
}
this.m_done[num3] = true;
if (this.m_channelEvents != null)
{
this.m_channelEvents[num3] = null;
}
flag = true;
channel.Dispose();
}
if (flag && (++num == this.m_channels.Length))
{
this.m_channelIndex = num3 = this.m_channels.Length;
break;
}
this.m_channelIndex = num3 = (num3 + 1) % this.m_channels.Length;
if (num3 == channelIndex)
{
try
{
if (this.m_channelEvents == null)
{
this.m_channelEvents = new ManualResetEventSlim[this.m_channels.Length];
}
num = 0;
for (int i = 0; i < this.m_channels.Length; i++)
{
if (!this.m_done[i] && this.m_channels[i].TryDequeue(ref this.m_currentElement, ref this.m_channelEvents[i]))
{
return(true);
}
if (this.m_channelEvents[i] == null)
{
if (!this.m_done[i])
{
this.m_done[i] = true;
this.m_channels[i].Dispose();
}
if (++num == this.m_channels.Length)
{
this.m_channelIndex = num3 = this.m_channels.Length;
break;
}
}
}
if (num3 == this.m_channels.Length)
{
break;
}
channelIndex = this.m_channelIndex = AsynchronousChannelMergeEnumerator <T> .WaitAny(this.m_channelEvents);
num = 0;
continue;
}
finally
{
for (int j = 0; j < this.m_channelEvents.Length; j++)
{
if (this.m_channelEvents[j] != null)
{
this.m_channels[j].DoneWithDequeueWait();
}
}
}
}
}
base.m_taskGroupState.QueryEnd(false);
return(false);
}
