internal override void WrapPartitionedStream <TKey>( PartitionedStream <TResult, TKey> inputStream, IPartitionedStreamRecipient <TResult> recipient, bool preferStriping, QuerySettings settings) { Contract.Assert(Child.OrdinalIndexState != OrdinalIndexState.Indexible, "Don't take this code path if the child is indexible."); PartitionedStream <TResult, int> inputIntStream; // If the index is not at least increasing, we need to reindex. if (m_prematureMerge) { ListQueryResults <TResult> results = ExecuteAndCollectResults( inputStream, inputStream.PartitionCount, Child.OutputOrdered, preferStriping, settings); inputIntStream = results.GetPartitionedStream(); } else { Contract.Assert(typeof(TKey) == typeof(int)); inputIntStream = (PartitionedStream <TResult, int>)((object)inputStream); } int partitionCount = inputStream.PartitionCount; FixedMaxHeap <int> sharedIndices = new FixedMaxHeap <int>(m_count); // an array used to track the sequence of indices leading up to the Nth index CountdownEvent sharredBarrier = new CountdownEvent(partitionCount); // a barrier to synchronize before yielding PartitionedStream <TResult, int> outputStream = new PartitionedStream <TResult, int>(partitionCount, Util.GetDefaultComparer <int>(), OrdinalIndexState); for (int i = 0; i < partitionCount; i++) { outputStream[i] = new TakeOrSkipQueryOperatorEnumerator( inputIntStream[i], m_count, m_take, sharedIndices, sharredBarrier, settings.CancellationState.MergedCancellationToken); } recipient.Receive(outputStream); }
internal TakeOrSkipQueryOperatorEnumerator(QueryOperatorEnumerator <TResult, int> source, int count, bool take, FixedMaxHeap <int> sharedIndices, CountdownEvent sharedBarrier, CancellationToken cancellationToken) { this.m_source = source; this.m_count = count; this.m_take = take; this.m_sharedIndices = sharedIndices; this.m_sharedBarrier = sharedBarrier; this.m_cancellationToken = cancellationToken; }
internal OrderedPipeliningMergeEnumerator(OrderPreservingPipeliningMergeHelper <TOutput> mergeHelper) : base(mergeHelper.m_taskGroupState) { int partitionCount = mergeHelper.m_partitions.PartitionCount; this.m_mergeHelper = mergeHelper; this.m_producerHeap = new FixedMaxHeap <OrderPreservingPipeliningMergeHelper <TOutput> .Producer>(partitionCount, OrderPreservingPipeliningMergeHelper <TOutput> .s_producerComparer); this.m_privateBuffer = new Queue <Pair <int, TOutput> > [partitionCount]; this.m_producerNextElement = new TOutput[partitionCount]; }
/// <summary> /// Constructor /// </summary> internal OrderedPipeliningMergeEnumerator(OrderPreservingPipeliningMergeHelper <TOutput, TKey> mergeHelper, IComparer <Producer <TKey> > producerComparer) : base(mergeHelper._taskGroupState) { int partitionCount = mergeHelper._partitions.PartitionCount; _mergeHelper = mergeHelper; _producerHeap = new FixedMaxHeap <Producer <TKey> >(partitionCount, producerComparer); _privateBuffer = new Queue <Pair <TKey, TOutput> > [partitionCount]; _producerNextElement = new TOutput[partitionCount]; }
private Shared <int> m_bufferIndex; // Our current index within the buffer. [allocate in moveNext to avoid false-sharing] //--------------------------------------------------------------------------------------- // Instantiates a new select enumerator. // internal TakeOrSkipQueryOperatorEnumerator( QueryOperatorEnumerator <TResult, int> source, int count, bool take, FixedMaxHeap <int> sharedIndices, CountdownEvent sharedBarrier, CancellationToken cancellationToken) { Contract.Assert(source != null); Contract.Assert(sharedIndices != null); Contract.Assert(sharedBarrier != null); Contract.Assert(sharedIndices.Size == count); m_source = source; m_count = count; m_take = take; m_sharedIndices = sharedIndices; m_sharedBarrier = sharedBarrier; m_cancellationToken = cancellationToken; }
private Shared <int>?_bufferIndex; // Our current index within the buffer. [allocate in moveNext to avoid false-sharing] //--------------------------------------------------------------------------------------- // Instantiates a new select enumerator. // internal TakeOrSkipQueryOperatorEnumerator( QueryOperatorEnumerator <TResult, TKey> source, bool take, FixedMaxHeap <TKey> sharedIndices, CountdownEvent sharedBarrier, CancellationToken cancellationToken, IComparer <TKey> keyComparer) { Debug.Assert(source != null); Debug.Assert(sharedIndices != null); Debug.Assert(sharedBarrier != null); Debug.Assert(keyComparer != null); _source = source; _count = sharedIndices.Size; _take = take; _sharedIndices = sharedIndices; _sharedBarrier = sharedBarrier; _cancellationToken = cancellationToken; _keyComparer = keyComparer; }
private void WrapHelper <TKey>(PartitionedStream <TResult, TKey> inputStream, IPartitionedStreamRecipient <TResult> recipient, QuerySettings settings) { int partitionCount = inputStream.PartitionCount; FixedMaxHeap <TKey> sharedIndices = new FixedMaxHeap <TKey>(_count, inputStream.KeyComparer); // an array used to track the sequence of indices leading up to the Nth index CountdownEvent sharedBarrier = new CountdownEvent(partitionCount); // a barrier to synchronize before yielding PartitionedStream <TResult, TKey> outputStream = new PartitionedStream <TResult, TKey>(partitionCount, inputStream.KeyComparer, OrdinalIndexState); for (int i = 0; i < partitionCount; i++) { outputStream[i] = new TakeOrSkipQueryOperatorEnumerator <TKey>( inputStream[i], _take, sharedIndices, sharedBarrier, settings.CancellationState.MergedCancellationToken, inputStream.KeyComparer); } recipient.Receive(outputStream); }
internal override void WrapPartitionedStream <TKey>(PartitionedStream <TResult, TKey> inputStream, IPartitionedStreamRecipient <TResult> recipient, bool preferStriping, QuerySettings settings) { PartitionedStream <TResult, int> stream; if (this.m_prematureMerge) { stream = QueryOperator <TResult> .ExecuteAndCollectResults <TKey>(inputStream, inputStream.PartitionCount, base.Child.OutputOrdered, preferStriping, settings).GetPartitionedStream(); } else { stream = (PartitionedStream <TResult, int>)inputStream; } int partitionCount = inputStream.PartitionCount; FixedMaxHeap <int> sharedIndices = new FixedMaxHeap <int>(this.m_count); CountdownEvent sharedBarrier = new CountdownEvent(partitionCount); PartitionedStream <TResult, int> partitionedStream = new PartitionedStream <TResult, int>(partitionCount, Util.GetDefaultComparer <int>(), this.OrdinalIndexState); for (int i = 0; i < partitionCount; i++) { partitionedStream[i] = new TakeOrSkipQueryOperatorEnumerator <TResult>(stream[i], this.m_count, this.m_take, sharedIndices, sharedBarrier, settings.CancellationState.MergedCancellationToken); } recipient.Receive <int>(partitionedStream); }