private async void ButtonParalellAsyn_Click(object sender, EventArgs e)
{
ButtonParalellLinq.Enabled = false;
try
{
textParallelAsym.Text = "Processing....";
ParallelExecutionMode parallelExecutionMode = ParallelExecutionMode.Default;
Enum.TryParse(this.comboParallelModes.SelectedItem?.ToString(), out parallelExecutionMode);
if (!Int32.TryParse(numericDegreeOfParalelism.Value.ToString(), out degreeParalelism))
{
throw new Exception("Invalid input parameter of degree paralelism. Must be a integer number");
}
Stopwatch watch = Stopwatch.StartNew();
List <ComplexObject> processedItems = await linqPerformanceManager.ComplexLinqAsParallelAsync(parallelExecutionMode, degreeParalelism);
watch.Stop();
textParallelAsym.Text = linqPerformanceManager.NumberOfElementProcessed() + " items processed in " + watch.ElapsedMilliseconds.ToString() + "ms";
}
catch (Exception exception)
{
textParallelAsym.Text = BuildTraceException(exception);
}
finally
{
ButtonParalellLinq.Enabled = true;
}
}
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;
}
//public static IParallelObservable<TSource> AsParallel<TSource>(
// this IObserver<TSource> source)
//{
// ParallelObserver<TSource> parallelObserver =
// new ParallelObserver<TSource>(source);
// return parallelObserver;
//}
public static IParallelObservable <TSource> WithExecutionMode <TSource>(
this IParallelObservable <TSource> source,
ParallelExecutionMode executionMode)
{
ParallelBaseSubject <TSource> parallelsubject = (ParallelBaseSubject <TSource>)source;
parallelsubject.ParallelExecutionMode_ = executionMode;
parallelsubject.BuildScheduler();
return(parallelsubject);
}
[MemberData(nameof(WithExecutionModeQueryData), new int[] { 1, 4 })] // DOP of 1 to verify sequential and 4 to verify parallel
public static void WithExecutionMode(
Labeled <ParallelQuery <int> > labeled,
int requestedDop, int expectedDop,
Labeled <Action <UsedTaskTracker, ParallelQuery <int> > > operation,
ParallelExecutionMode mode)
{
UsedTaskTracker tracker = new UsedTaskTracker();
operation.Item(tracker, labeled.Item.WithDegreeOfParallelism(requestedDop).WithExecutionMode(mode));
Assert.Equal(expectedDop, tracker.UniqueTasksCount);
}
public List <ComplexObject> ComplexLinqAsParallel(ParallelExecutionMode parallelExecutionMode, int degreeOfParalelism)
{
List <ComplexObject> result = collectionObjects.AsParallel()
.WithExecutionMode(parallelExecutionMode)
.WithDegreeOfParallelism(degreeOfParalelism)
.Where(FilterWhere)
.Select(SelectFilter)
.OrderBy(x => x.Date)
.ThenBy(x => x.Name)
.ToList();
return(result);
}
//-----------------------------------------------------------------------------------
// 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 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;
}
private static void RunSequenceEqualTest3Core(ParallelExecutionMode mode)
{
int collectionLength = 1999;
try
{
new DisposeExceptionEnumerable <int>(Enumerable.Range(0, collectionLength)).AsParallel()
.WithDegreeOfParallelism(2)
.WithExecutionMode(ParallelExecutionMode.ForceParallelism)
.SequenceEqual(new DisposeExceptionEnumerable <int>(Enumerable.Range(0, collectionLength)).AsParallel());
}
catch (AggregateException)
{
return;
}
catch (Exception ex)
{
Assert.True(false, string.Format("RunSequenceEqualTest3(mode={1}): > Failed: Expected AggregateException, got {0}", ex.GetType(), mode));
}
Assert.True(false, string.Format("RunSequenceEqualTest3(mode={0}): > Failed: Expected AggregateException, got no exception", mode));
}
/// <summary>
/// Tests OrderBy() followed by a SelectMany, where the outer input sequence
/// contains duplicates.
/// </summary>
private static void RunSelectManyTest3Core(int size, ParallelExecutionMode mode)
{
int[] srcOuter = Enumerable.Repeat(0, size).ToArray();
int[] srcInner = Enumerable.Range(0, size).ToArray();
IEnumerable <int> query =
srcOuter.AsParallel()
.WithExecutionMode(mode)
.OrderBy(x => x)
.SelectMany(x => srcInner);
int next = 0;
foreach (var x in query)
{
if (x != next)
{
Assert.True(false, string.Format("RunSelectManyTest3(size = {2}: FAILED. expected {0} got {1}", next, x, size));
}
next = (next + 1) % size;
}
}
internal ParallelExecutionModeNode(ParallelExecutionMode mode, QueryBaseNode <T> parent)
: base(parent)
{
this.mode = mode;
}
// Check that some queries run in parallel by default, and some require forcing.
public static void WithExecutionMode(Labeled <ParallelQuery <int> > labeled, int count,
Labeled <Action <ParVerifier, ParallelQuery <int> > > operation, ParallelExecutionMode mode)
{
ParVerifier verifier = new ParVerifier();
operation.Item(verifier, labeled.Item.WithExecutionMode(mode));
verifier.AssertPassed();
}
public async Task <List <ComplexObject> > ComplexLinqAsParallelAsync(ParallelExecutionMode parallelExecutionMode, int degreeOfParalelism)
{
return(await Task.Run(() => { return ComplexLinqAsParallel(parallelExecutionMode, degreeOfParalelism); }));
}
[MemberData("WithExecutionModeQueryData", new int[] { 1, 4 })] // DOP of 1 to verify sequential and 4 to verify parallel
public static void WithExecutionMode(
Labeled<ParallelQuery<int>> labeled,
int requestedDop, int expectedDop,
Labeled<Action<UsedTaskTracker, ParallelQuery<int>>> operation,
ParallelExecutionMode mode)
{
UsedTaskTracker tracker = new UsedTaskTracker();
operation.Item(tracker, labeled.Item.WithDegreeOfParallelism(requestedDop).WithExecutionMode(mode));
Assert.Equal(expectedDop, tracker.UniqueTasksCount);
}
public static void WithExecutionMode_Multiple(ParallelExecutionMode first, ParallelExecutionMode second)
{
Assert.Throws<InvalidOperationException>(() => ParallelEnumerable.Range(0, 1).WithExecutionMode(first).WithExecutionMode(second));
}
public static ParallelQuery <TSource> WithExecutionMode <TSource>(this ParallelQuery <TSource> source, ParallelExecutionMode executionMode)
{
return(source);
}
public static ParallelQuery <TSource> WithExecutionMode <TSource>(this ParallelQuery <TSource> source, ParallelExecutionMode executionMode)
{
throw new NotImplementedException();
}
public static void WithExecutionMode_Multiple(ParallelExecutionMode first, ParallelExecutionMode second)
{
Assert.Throws <InvalidOperationException>(() => ParallelEnumerable.Range(0, 1).WithExecutionMode(first).WithExecutionMode(second));
}
public static ParallelQuery <TSource> WithExecutionMode <TSource>(ParallelQuery <TSource> source, ParallelExecutionMode executionMode)
{
Contract.Ensures(Contract.Result <System.Linq.ParallelQuery <TSource> >() != null);
return(default(ParallelQuery <TSource>));
}
