internal static Task[] Process <TSource, TElement> (QueryBaseNode <TSource> node,
Action <TElement, CancellationToken> call,
Func <QueryBaseNode <TSource>, QueryOptions, IList <IEnumerable <TElement> > > acquisitionFunc,
QueryOptions options)
{
return(Process <TSource, TElement> (node, call, acquisitionFunc, null, options));
}
internal static void ProcessAndBlock <T> (QueryBaseNode <T> node, Action <T, CancellationToken> call)
{
QueryOptions options = CheckQuery(node, true);
Task[] tasks = Process(node, call, (n, o) => n.GetEnumerables(o), options);
Task.WaitAll(tasks, options.Token);
}
internal static QueryOptions CheckQuery <T> (QueryBaseNode <T> startingNode, int partitionCount)
{
QueryCheckerVisitor visitor = new QueryCheckerVisitor(partitionCount);
startingNode.Visit(visitor);
return(visitor.Options);
}
internal static bool IsOrdered <TSource> (this QueryBaseNode <TSource> source)
{
QueryIsOrderedVisitor visitor = new QueryIsOrderedVisitor();
source.Visit(visitor);
return(visitor.BehindOrderGuard);
}
public QuerySymbol(
ISymbol containingSymbol,
QueryBaseNode declaration,
DiagnosticBag diagnostics)
: base(containingSymbol)
{
// TODO query
}
internal static Action ProcessAndCallback <T> (QueryBaseNode <T> node, Action <T, CancellationToken> call,
Action callback, QueryOptions options)
{
Task[] tasks = Process(node, call, (n, o) => n.GetEnumerables(o), options);
if (callback != null)
{
Task.Factory.ContinueWhenAll(tasks, (_) => callback());
}
return(() => Task.WaitAll(tasks, options.Token));
}
internal static Action ProcessAndCallback <T> (QueryBaseNode <T> node, Action <KeyValuePair <long, T>, CancellationToken> call,
Action endAction,
Action callback, QueryOptions options)
{
Task[] tasks = Process(node, call, new QueryBaseNodeHelper <T> ().GetOrderedEnumerables, endAction, options);
if (callback != null)
{
Task.Factory.ContinueWhenAll(tasks, (_) => callback());
}
return(() => Task.WaitAll(tasks, options.Token));
}
internal static Task[] Process <TSource, TElement> (QueryBaseNode <TSource> node,
Action <TElement, CancellationToken> call,
Func <QueryBaseNode <TSource>, QueryOptions, IList <IEnumerable <TElement> > > acquisitionFunc,
Action endAction,
QueryOptions options)
{
CancellationTokenSource src
= CancellationTokenSource.CreateLinkedTokenSource(options.ImplementerToken, options.Token);
IList <IEnumerable <TElement> > enumerables = acquisitionFunc(node, options);
Task[] tasks = new Task[enumerables.Count];
for (int i = 0; i < tasks.Length; i++)
{
int index = i;
tasks[i] = Task.Factory.StartNew(() => {
try {
foreach (TElement item in enumerables[index])
{
if (!CheckTokens(options))
{
break;
}
try {
call(item, src.Token);
} catch (OperationCanceledException canceledException) {
if (canceledException.CancellationToken != src.Token)
{
throw canceledException;
}
}
if (!CheckTokens(options))
{
break;
}
}
} finally {
if (endAction != null)
{
endAction();
}
}
}, options.Token, TaskCreationOptions.AttachedToParent | TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
return(tasks);
}
internal static void ProcessAndAggregate <T, U> (QueryBaseNode <T> node,
Func <U> seedFunc,
Func <U, T, U> localCall,
Action <IList <U> > call)
{
QueryOptions options = CheckQuery(node, true);
IList <IEnumerable <T> > enumerables = node.GetEnumerables(options);
U[] locals = new U[enumerables.Count];
Task[] tasks = new Task[enumerables.Count];
if (seedFunc != null)
{
for (int i = 0; i < locals.Length; i++)
{
locals[i] = seedFunc();
}
}
for (int i = 0; i < tasks.Length; i++)
{
var procSlot = new AggregateProcessSlot <T, U> (options,
i,
enumerables[i].GetEnumerator(),
locals,
localCall,
seedFunc);
tasks[i] = Task.Factory.StartNew(procSlot.Process, options.Token);
}
Task.WaitAll(tasks, options.Token);
if (call != null)
{
call(locals);
}
}
internal ParallelQueryEnumerator(QueryBaseNode <T> node)
{
this.options = ParallelExecuter.CheckQuery(node);
if (options.ShouldBeSequential && options.Mode != ParallelExecutionMode.ForceParallelism)
{
IEnumerable <T> buffer = node.GetSequential();
loader = buffer.GetEnumerator();
}
else
{
Setup();
// Launch adding to the buffer asynchronously via Tasks
if (options.BehindOrderGuard.Value)
{
waitAction = ParallelExecuter.ProcessAndCallback(node,
ordEnumerator.Add,
ordEnumerator.EndParticipation,
ordEnumerator.Stop,
options);
}
else
{
waitAction = ParallelExecuter.ProcessAndCallback(node,
buffer.Add,
buffer.CompleteAdding,
options);
}
if (options.Options.HasValue && options.Options.Value == ParallelMergeOptions.FullyBuffered)
{
waitAction();
}
}
}
public void Visit (QueryBaseNode node)
{
}
public void Visit (QueryBaseNode node)
{
// Nothing to do atm. Later we can check if the node is a
// Take or a Skip and set accordingly UseStrip
}
public void Visit <T> (QueryBaseNode <T> node)
{
}
public void Visit(QueryBaseNode node)
{
}
internal IList <IEnumerable <T> > GetEnumerables(QueryBaseNode <T> source, QueryOptions options)
{
return(source.GetEnumerables(options));
}
internal static QueryOptions CheckQuery <T> (QueryBaseNode <T> startingNode, bool blocking)
{
return(CheckQuery(startingNode, GetBestWorkerNumber(blocking)));
}
internal static QueryOptions CheckQuery <T> (QueryBaseNode <T> startingNode)
{
return(CheckQuery <T> (startingNode, false));
}
internal IList <IEnumerable <KeyValuePair <long, T> > > GetOrderedEnumerables(QueryBaseNode <T> source, QueryOptions options)
{
return(source.GetOrderedEnumerables(options));
}
public void Visit(QueryBaseNode node)
{
// Nothing to do atm. Later we can check if the node is a
// Take or a Skip and set accordingly UseStrip
}