示例#1
0
 internal OrderPreservingMergeHelper(PartitionedStream <TInputOutput, TKey> partitions, TaskScheduler taskScheduler, CancellationState cancellationState, int queryId)
 {
     this.m_taskGroupState = new QueryTaskGroupState(cancellationState, queryId);
     this.m_partitions     = partitions;
     this.m_results        = new System.Linq.Parallel.Shared <TInputOutput[]>(null);
     this.m_taskScheduler  = taskScheduler;
 }
示例#2
0
        internal QuerySettings WithPerExecutionSettings(CancellationTokenSource topLevelCancellationTokenSource, System.Linq.Parallel.Shared <bool> topLevelDisposedFlag)
        {
            QuerySettings settings = new QuerySettings(this.TaskScheduler, this.DegreeOfParallelism, this.CancellationState.ExternalCancellationToken, this.ExecutionMode, this.MergeOptions);

            settings.CancellationState.InternalCancellationTokenSource = topLevelCancellationTokenSource;
            settings.CancellationState.MergedCancellationTokenSource   = CancellationTokenSource.CreateLinkedTokenSource(settings.CancellationState.InternalCancellationTokenSource.Token, settings.CancellationState.ExternalCancellationToken);
            settings.CancellationState.TopLevelDisposedFlag            = topLevelDisposedFlag;
            settings.m_queryId = PlinqEtwProvider.NextQueryId();
            return(settings);
        }
        internal static void Spool(QueryTaskGroupState groupState, PartitionedStream <TInputOutput, TKey> partitions, System.Linq.Parallel.Shared <TInputOutput[]> results, TaskScheduler taskScheduler)
        {
            int maxToRunInParallel = partitions.PartitionCount - 1;

            SortHelper <TInputOutput, TKey>[] sortHelpers = SortHelper <TInputOutput, TKey> .GenerateSortHelpers(partitions, groupState);

            Task rootTask = new Task(delegate {
                for (int k = 0; k < maxToRunInParallel; k++)
                {
                    new OrderPreservingSpoolingTask <TInputOutput, TKey>(k, groupState, results, sortHelpers[k]).RunAsynchronously(taskScheduler);
                }
                new OrderPreservingSpoolingTask <TInputOutput, TKey>(maxToRunInParallel, groupState, results, sortHelpers[maxToRunInParallel]).RunSynchronously(taskScheduler);
            });

            groupState.QueryBegin(rootTask);
            rootTask.RunSynchronously(taskScheduler);
            for (int j = 0; j < sortHelpers.Length; j++)
            {
                sortHelpers[j].Dispose();
            }
            groupState.QueryEnd(false);
        }
 private OrderPreservingSpoolingTask(int taskIndex, QueryTaskGroupState groupState, System.Linq.Parallel.Shared <TInputOutput[]> results, SortHelper <TInputOutput> sortHelper) : base(taskIndex, groupState)
 {
     this.m_results    = results;
     this.m_sortHelper = sortHelper;
 }