internal virtual IEnumerator <TOutput> GetEnumerator(ParallelMergeOptions?mergeOptions, bool suppressOrderPreservation)
{
// Return a dummy enumerator that will call back GetOpenedEnumerator() on 'this' QueryOperator
// the first time the user calls MoveNext(). We do this to prevent executing the query if user
// never calls MoveNext().
return(new QueryOpeningEnumerator <TOutput>(this, mergeOptions, suppressOrderPreservation));
}
//-----------------------------------------------------------------------------------
// Combines two sets of options.
//
internal QuerySettings Merge(QuerySettings settings2)
{
if (this.TaskScheduler != null && settings2.TaskScheduler != null)
{
throw new InvalidOperationException(SR.ParallelQuery_DuplicateTaskScheduler);
}
if (this.DegreeOfParallelism != null && settings2.DegreeOfParallelism != null)
{
throw new InvalidOperationException(SR.ParallelQuery_DuplicateDOP);
}
if (this.CancellationState.ExternalCancellationToken.CanBeCanceled && settings2.CancellationState.ExternalCancellationToken.CanBeCanceled)
{
throw new InvalidOperationException(SR.ParallelQuery_DuplicateWithCancellation);
}
if (this.ExecutionMode != null && settings2.ExecutionMode != null)
{
throw new InvalidOperationException(SR.ParallelQuery_DuplicateExecutionMode);
}
if (this.MergeOptions != null && settings2.MergeOptions != null)
{
throw new InvalidOperationException(SR.ParallelQuery_DuplicateMergeOptions);
}
TaskScheduler? tm = this.TaskScheduler ?? settings2.TaskScheduler;
int? dop = this.DegreeOfParallelism.HasValue ? this.DegreeOfParallelism : settings2.DegreeOfParallelism;
CancellationToken externalCancellationToken = (this.CancellationState.ExternalCancellationToken.CanBeCanceled) ? this.CancellationState.ExternalCancellationToken : settings2.CancellationState.ExternalCancellationToken;
ParallelExecutionMode?executionMode = this.ExecutionMode.HasValue ? this.ExecutionMode : settings2.ExecutionMode;
ParallelMergeOptions? mergeOptions = this.MergeOptions.HasValue ? this.MergeOptions : settings2.MergeOptions;
return(new QuerySettings(tm, dop, externalCancellationToken, executionMode, mergeOptions));
}
internal IEnumerator <TOutput> GetOpenedEnumerator(ParallelMergeOptions?mergeOptions, bool suppressOrder, bool forEffect, QuerySettings querySettings)
{
if ((((ParallelExecutionMode)querySettings.ExecutionMode.Value) == ParallelExecutionMode.Default) && this.LimitsParallelism)
{
return(ExceptionAggregator.WrapEnumerable <TOutput>(this.AsSequentialQuery(querySettings.CancellationState.ExternalCancellationToken), querySettings.CancellationState).GetEnumerator());
}
QueryResults <TOutput> queryResults = this.GetQueryResults(querySettings);
if (!mergeOptions.HasValue)
{
mergeOptions = querySettings.MergeOptions;
}
if (querySettings.CancellationState.MergedCancellationToken.IsCancellationRequested)
{
if (querySettings.CancellationState.ExternalCancellationToken.IsCancellationRequested)
{
throw new OperationCanceledException(querySettings.CancellationState.ExternalCancellationToken);
}
throw new OperationCanceledException();
}
bool outputOrdered = this.OutputOrdered && !suppressOrder;
PartitionedStreamMerger <TOutput> recipient = new PartitionedStreamMerger <TOutput>(forEffect, mergeOptions.GetValueOrDefault(), querySettings.TaskScheduler, outputOrdered, querySettings.CancellationState, querySettings.QueryId);
queryResults.GivePartitionedStream(recipient);
if (forEffect)
{
return(null);
}
return(recipient.MergeExecutor.GetEnumerator());
}
internal override IEnumerator <TSource> GetEnumerator(ParallelMergeOptions?mergeOptions, bool suppressOrderPreservation)
{
if (_child is ScanQueryOperator <TSource> childAsScan)
{
return(childAsScan.Data.GetEnumerator());
}
return(base.GetEnumerator(mergeOptions, suppressOrderPreservation));
}
internal QueryOpeningEnumerator(QueryOperator <TOutput> queryOperator, ParallelMergeOptions?mergeOptions, bool suppressOrderPreservation)
{
this.m_topLevelDisposedFlag = new Shared <bool>(false);
this.m_topLevelCancellationTokenSource = new CancellationTokenSource();
this.m_queryOperator = queryOperator;
this.m_mergeOptions = mergeOptions;
this.m_suppressOrderPreservation = suppressOrderPreservation;
}
internal QueryOpeningEnumerator(QueryOperator <TOutput> queryOperator, ParallelMergeOptions?mergeOptions, bool suppressOrderPreservation)
{
Debug.Assert(queryOperator != null);
_queryOperator = queryOperator;
_mergeOptions = mergeOptions;
_suppressOrderPreservation = suppressOrderPreservation;
}
internal QuerySettings(System.Threading.Tasks.TaskScheduler taskScheduler, int? degreeOfParallelism, CancellationToken externalCancellationToken, ParallelExecutionMode? executionMode, ParallelMergeOptions? mergeOptions)
{
this.m_taskScheduler = taskScheduler;
this.m_degreeOfParallelism = degreeOfParallelism;
this.m_cancellationState = new System.Linq.Parallel.CancellationState(externalCancellationToken);
this.m_executionMode = executionMode;
this.m_mergeOptions = mergeOptions;
this.m_queryId = -1;
}
internal QuerySettings(System.Threading.Tasks.TaskScheduler taskScheduler, int?degreeOfParallelism, CancellationToken externalCancellationToken, ParallelExecutionMode?executionMode, ParallelMergeOptions?mergeOptions)
{
this.m_taskScheduler = taskScheduler;
this.m_degreeOfParallelism = degreeOfParallelism;
this.m_cancellationState = new System.Linq.Parallel.CancellationState(externalCancellationToken);
this.m_executionMode = executionMode;
this.m_mergeOptions = mergeOptions;
this.m_queryId = -1;
}
//---------------------------------------------------------------------------------------
// The GetOpenedEnumerator method return an enumerator that walks the contents of a query.
// The enumerator will be "opened", which means that PLINQ will start executing the query
// immediately, even before the user calls MoveNext() for the first time.
//
internal IEnumerator <TOutput> GetOpenedEnumerator(ParallelMergeOptions?mergeOptions, bool suppressOrder, bool forEffect,
QuerySettings querySettings)
{
// If the top-level enumerator forces a premature merge, run the query sequentially.
if (querySettings.ExecutionMode.Value == ParallelExecutionMode.Default && LimitsParallelism)
{
IEnumerable <TOutput> opSequential = AsSequentialQuery(querySettings.CancellationState.ExternalCancellationToken);
return(ExceptionAggregator.WrapEnumerable(opSequential, querySettings.CancellationState).GetEnumerator());
}
QueryResults <TOutput> queryResults = GetQueryResults(querySettings);
if (mergeOptions == null)
{
mergeOptions = querySettings.MergeOptions;
}
Contract.Assert(mergeOptions != null);
// Top-level pre-emptive cancellation test.
// This handles situations where cancellation has occured before execution commences
// The handling for in-execution occurs in QueryTaskGroupState.QueryEnd()
if (querySettings.CancellationState.MergedCancellationToken.IsCancellationRequested)
{
if (querySettings.CancellationState.ExternalCancellationToken.IsCancellationRequested)
{
#if PFX_LEGACY_3_5
throw new OperationCanceledException2(querySettings.CancellationState.ExternalCancellationToken);
#else
throw new OperationCanceledException(querySettings.CancellationState.ExternalCancellationToken);
#endif
}
else
{
throw new OperationCanceledException();
}
}
bool orderedMerge = OutputOrdered && !suppressOrder;
PartitionedStreamMerger <TOutput> merger = new PartitionedStreamMerger <TOutput>(forEffect, mergeOptions.GetValueOrDefault(),
querySettings.TaskScheduler,
orderedMerge,
querySettings.CancellationState,
querySettings.QueryId);
queryResults.GivePartitionedStream(merger); // hook up the data flow between the operator-executors, starting from the merger.
if (forEffect)
{
return(null);
}
return(merger.MergeExecutor.GetEnumerator());
}
void MergeOptions(OptionsList list)
{
if (list.Item1 != null)
{
if (options == null)
{
options = list.Item1;
}
else
{
Throw("WithMergeOptions");
}
}
if (list.Item2 != null)
{
if (mode == null)
{
mode = list.Item2;
}
else
{
Throw("WithExecutionMode");
}
}
if (list.Item3 != null)
{
if (token == null)
{
token = list.Item3;
}
else
{
Throw("WithCancellationToken");
}
}
if (list.Item4 != -1)
{
if (degreeOfParallelism == null)
{
degreeOfParallelism = list.Item4;
}
else
{
Throw("WithDegreeOfParallelism");
}
}
// That one is treated specially
if (list.Item5 != null)
{
implementerToken = implementerToken.Chain(list.Item5);
}
}
internal override IEnumerator <TSource> GetEnumerator(ParallelMergeOptions?mergeOptions, bool suppressOrderPreservation)
{
ScanQueryOperator <TSource> child = this.m_child as ScanQueryOperator <TSource>;
if (child != null)
{
return(child.Data.GetEnumerator());
}
return(base.GetEnumerator(mergeOptions, suppressOrderPreservation));
}
//-----------------------------------------------------------------------------------
// Constructs a new settings structure.
//
internal QuerySettings(TaskScheduler?taskScheduler, int?degreeOfParallelism,
CancellationToken externalCancellationToken, ParallelExecutionMode?executionMode,
ParallelMergeOptions?mergeOptions)
{
_taskScheduler = taskScheduler;
_degreeOfParallelism = degreeOfParallelism;
_cancellationState = new CancellationState(externalCancellationToken);
_executionMode = executionMode;
_mergeOptions = mergeOptions;
_queryId = -1;
Debug.Assert(_cancellationState != null);
}
//-----------------------------------------------------------------------------------
// Constructs a new settings structure.
//
internal QuerySettings(TaskScheduler taskScheduler, int?degreeOfParallelism,
CancellationToken externalCancellationToken, ParallelExecutionMode?executionMode,
ParallelMergeOptions?mergeOptions)
{
m_taskScheduler = taskScheduler;
m_degreeOfParallelism = degreeOfParallelism;
m_cancellationState = new CancellationState(externalCancellationToken);
m_executionMode = executionMode;
m_mergeOptions = mergeOptions;
m_queryId = -1;
Contract.Assert(m_cancellationState != null);
}
public QueryOptions (ParallelMergeOptions? options,
ParallelExecutionMode? mode,
CancellationToken token,
bool useStrip,
bool? behindOrderGuard,
int partitionCount,
CancellationToken implementerToken)
{
Options = options;
Mode = mode;
Token = token;
UseStrip = useStrip;
BehindOrderGuard = behindOrderGuard;
PartitionCount = partitionCount;
PartitionerSettings = null;
ImplementerToken = implementerToken;
}
public QueryOptions(ParallelMergeOptions?options,
ParallelExecutionMode?mode,
CancellationToken token,
bool useStrip,
bool?behindOrderGuard,
int partitionCount,
CancellationToken implementerToken,
bool shouldBeSequential)
{
Options = options;
Mode = mode;
Token = token;
UseStrip = useStrip;
BehindOrderGuard = behindOrderGuard;
PartitionCount = partitionCount;
PartitionerSettings = null;
ImplementerToken = implementerToken;
ShouldBeSequential = shouldBeSequential;
MergeTokens(token, implementerToken);
}
//-----------------------------------------------------------------------------------
// Constructs a new settings structure.
//
internal QuerySettings(TaskScheduler taskScheduler, int? degreeOfParallelism,
CancellationToken externalCancellationToken, ParallelExecutionMode? executionMode,
ParallelMergeOptions? mergeOptions)
{
_taskScheduler = taskScheduler;
_degreeOfParallelism = degreeOfParallelism;
_cancellationState = new CancellationState(externalCancellationToken);
_executionMode = executionMode;
_mergeOptions = mergeOptions;
_queryId = -1;
Contract.Assert(_cancellationState != null);
}
public IEnumerator <TOutput> GetEnumerator(ParallelMergeOptions?mergeOptions)
{
return(this.GetEnumerator(mergeOptions, false));
}
void MergeOptions (OptionsList list)
{
if (list.Item1 != null) {
if (options == null)
options = list.Item1;
else
Throw ("WithMergeOptions");
}
if (list.Item2 != null) {
if (mode == null)
mode = list.Item2;
else
Throw ("WithExecutionMode");
}
if (list.Item3 != null) {
if (token == null)
token = list.Item3;
else
Throw ("WithCancellationToken");
}
if (list.Item4 != -1) {
if (degreeOfParallelism == null)
degreeOfParallelism = list.Item4;
else
Throw ("WithDegreeOfParallelism");
}
// That one is treated specially
if (list.Item5 != null) {
implementerToken = implementerToken.Chain (list.Item5);
}
}
public IEnumerator <TOutput> GetEnumerator(ParallelMergeOptions?mergeOptions)
{
// Pass through the value supplied for pipelining, and do not suppress
// order preservation by default.
return(GetEnumerator(mergeOptions, false));
}
internal virtual IEnumerator <TOutput> GetEnumerator(ParallelMergeOptions?mergeOptions, bool suppressOrderPreservation)
{
return(new QueryOpeningEnumerator <TOutput>((QueryOperator <TOutput>) this, mergeOptions, suppressOrderPreservation));
}
internal override IEnumerator <TElement> GetEnumerator(ParallelMergeOptions?mergeOptions, bool suppressOrderPreservation)
{
return(this.m_data.GetEnumerator());
}
