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 }