// 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 static void RunPlinqModesTests()
{
if (Environment.ProcessorCount == 1)
{
// Test doesn't apply to DOP == 1. It verifies that work is actually
// happening in parallel, which won't be the case with DOP == 1.
return;
}
Action <ParallelExecutionMode, Verifier>[] hardQueries =
{
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).Where(x => true).TakeWhile((x, i) => true).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).Where(x => true).TakeWhile((x, i) => true).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).ElementAt(5),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select((x, i) => verifier.Verify(x)).Iterate(),
};
Action <ParallelExecutionMode, Verifier>[] easyQueries =
{
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.TakeWhile(x => true).Select(x => verifier.Verify(x)).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.TakeWhile(x => true).Select(x => verifier.Verify(x)).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).ToArray().AsParallel()
.Select(x => verifier.Verify(x)).Take(100).WithExecutionMode(mode).ToArray(),
(mode, verifier) => Enumerable.Range(0, 1000).ToArray().AsParallel().WithExecutionMode(mode)
.Take(100).Select(x => verifier.Verify(x)).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).ElementAt(5),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).SelectMany((x, i) => Enumerable.Repeat(1, 2)).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).SelectMany((x, i) => Enumerable.Repeat(1, 2)).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode).AsUnordered()
.Select(x => verifier.Verify(x)).Select((x, i) => x).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode).AsUnordered().Where(x => true).Select(x => verifier.Verify(x)).First(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).OrderBy(x => x).ToArray(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).OrderBy(x => x).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().AsOrdered().WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x))
.Concat(Enumerable.Range(0, 1000).AsParallel().AsOrdered().Where(x => true))
.ToList(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).Take(100).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).Take(100).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).TakeWhile(x => true).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).TakeWhile(x => true).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000)
.OrderBy(x => x).Select(x => verifier.Verify(x)).WithExecutionMode(mode).ElementAt(5),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.OrderBy(x => x).Select((x, i) => verifier.Verify(x)).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).OrderBy(x => x).Take(10000).Iterate(),
};
// Verify that all queries in 'easyQueries' run in parallel in default mode
for (int i = 0; i < easyQueries.Length; i++)
{
Verifier verifier = new ParVerifier();
easyQueries[i].Invoke(ParallelExecutionMode.Default, verifier);
if (!verifier.Passed)
{
Assert.True(false, string.Format("Easy query {0} expected to run in parallel in default mode", i));
}
}
// Verify that all queries in 'easyQueries' always run in forced mode
for (int i = 0; i < easyQueries.Length; i++)
{
Verifier verifier = new ParVerifier();
easyQueries[i].Invoke(ParallelExecutionMode.ForceParallelism, verifier);
if (!verifier.Passed)
{
Assert.True(false, string.Format("Easy query {0} expected to run in parallel in force-parallelism mode", i));
}
}
// Verify that all queries in 'easyQueries' always run in forced mode
for (int i = 0; i < hardQueries.Length; i++)
{
Verifier verifier = new ParVerifier();
hardQueries[i].Invoke(ParallelExecutionMode.ForceParallelism, verifier);
if (!verifier.Passed)
{
Assert.True(false, string.Format("Hard query {0} expected to run in parallel in force-parallelism mode", i));
}
}
}
internal static bool RunPlinqModesTests()
{
if (System.Linq.Parallel.Scheduling.GetDefaultDegreeOfParallelism() == 1)
{
Console.WriteLine(" - Test does not apply to the DOP=1 case.");
return(true);
}
Action <ParallelExecutionMode, Verifier>[] hardQueries =
{
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).TakeWhile(x => true).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).TakeWhile(x => true).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).Take(100).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).Take(100).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).OrderBy(x => x).Select(x => verifier.Verify(x)).ElementAt(5),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).ElementAt(5),
(mode, verifier) => ParallelEnumerable.Range(0, 1000)
.OrderBy(x => x).Select(x => verifier.Verify(x)).WithExecutionMode(mode).ElementAt(5),
};
Action <ParallelExecutionMode, Verifier>[] easyQueries =
{
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.TakeWhile(x => true).Select(x => verifier.Verify(x)).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.TakeWhile(x => true).Select(x => verifier.Verify(x)).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).ToArray().AsParallel()
.Select(x => verifier.Verify(x)).Take(100).WithExecutionMode(mode).ToArray(),
(mode, verifier) => Enumerable.Range(0, 1000).ToArray().AsParallel().WithExecutionMode(mode)
.Take(100).Select(x => verifier.Verify(x)).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).ElementAt(5),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).SelectMany((x, i) => Enumerable.Repeat(1, 2)).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).SelectMany((x, i) => Enumerable.Repeat(1, 2)).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode).AsUnordered()
.Select(x => verifier.Verify(x)).Select((x, i) => x).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode).AsUnordered().Where(x => true).Select(x => verifier.Verify(x)).First(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).OrderBy(x => x).ToArray(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).OrderBy(x => x).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().AsOrdered().WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x))
.Concat(Enumerable.Range(0, 1000).AsParallel().AsOrdered().Where(x => true))
.ToList(),
};
// Verify that all queries in 'easyQueries' run in parallel in default mode
bool passed = true;
for (int i = 0; i < easyQueries.Length; i++)
{
Verifier verifier = new ParVerifier();
easyQueries[i].Invoke(ParallelExecutionMode.Default, verifier);
if (!verifier.Passed)
{
passed = false;
Console.WriteLine("Easy query {0} expected to run in parallel in default mode", i);
}
}
// Verify that all queries in 'easyQueries' always run in forced mode
for (int i = 0; i < easyQueries.Length; i++)
{
Verifier verifier = new ParVerifier();
easyQueries[i].Invoke(ParallelExecutionMode.ForceParallelism, verifier);
if (!verifier.Passed)
{
passed = false;
Console.WriteLine("Easy query {0} expected to run in parallel in force-parallelism mode", i);
}
}
// Verify that all queries in 'easyQueries' run sequentially in default mode
for (int i = 0; i < hardQueries.Length; i++)
{
Verifier verifier = new SeqVerifier();
hardQueries[i].Invoke(ParallelExecutionMode.Default, verifier);
if (!verifier.Passed)
{
passed = false;
Console.WriteLine("Hard query {0} expected to run sequentially in default mode", i);
}
}
// Verify that all queries in 'easyQueries' always run in forced mode
for (int i = 0; i < hardQueries.Length; i++)
{
Verifier verifier = new ParVerifier();
hardQueries[i].Invoke(ParallelExecutionMode.ForceParallelism, verifier);
if (!verifier.Passed)
{
passed = false;
Console.WriteLine("Hard query {0} expected to run in parallel in force-parallelism mode", i);
}
}
return(passed);
}
public static void RunPlinqModesTests()
{
// I would assume that this gets the number of processors (ie. Environment.ProcessorCount)
// but since we are trying to exclude dependencies that aren't part of the contract, we
// can't use System.Runtime.Extensions. So we had to remove this check.
// if (SchedulingProxy.GetDefaultDegreeOfParallelism() == 1)
// {
// Console.WriteLine(" - Test does not apply to the DOP=1 case.");
// return true;
// }
Action <ParallelExecutionMode, Verifier>[] hardQueries =
{
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).Where(x => true).TakeWhile((x, i) => true).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).Where(x => true).TakeWhile((x, i) => true).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).ElementAt(5),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select((x, i) => verifier.Verify(x)).Iterate(),
};
Action <ParallelExecutionMode, Verifier>[] easyQueries =
{
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.TakeWhile(x => true).Select(x => verifier.Verify(x)).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.TakeWhile(x => true).Select(x => verifier.Verify(x)).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).ToArray().AsParallel()
.Select(x => verifier.Verify(x)).Take(100).WithExecutionMode(mode).ToArray(),
(mode, verifier) => Enumerable.Range(0, 1000).ToArray().AsParallel().WithExecutionMode(mode)
.Take(100).Select(x => verifier.Verify(x)).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).ElementAt(5),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).SelectMany((x, i) => Enumerable.Repeat(1, 2)).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).SelectMany((x, i) => Enumerable.Repeat(1, 2)).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode).AsUnordered()
.Select(x => verifier.Verify(x)).Select((x, i) => x).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode).AsUnordered().Where(x => true).Select(x => verifier.Verify(x)).First(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).OrderBy(x => x).ToArray(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).OrderBy(x => x).Iterate(),
(mode, verifier) => Enumerable.Range(0, 1000).AsParallel().AsOrdered().WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x))
.Concat(Enumerable.Range(0, 1000).AsParallel().AsOrdered().Where(x => true))
.ToList(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).Take(100).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).Take(100).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).TakeWhile(x => true).ToArray(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Select(x => verifier.Verify(x)).TakeWhile(x => true).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000)
.OrderBy(x => x).Select(x => verifier.Verify(x)).WithExecutionMode(mode).ElementAt(5),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.OrderBy(x => x).Select((x, i) => verifier.Verify(x)).Iterate(),
(mode, verifier) => ParallelEnumerable.Range(0, 1000).WithExecutionMode(mode)
.Where(x => true).Select(x => verifier.Verify(x)).OrderBy(x => x).Take(10000).Iterate(),
};
// Verify that all queries in 'easyQueries' run in parallel in default mode
for (int i = 0; i < easyQueries.Length; i++)
{
Verifier verifier = new ParVerifier();
easyQueries[i].Invoke(ParallelExecutionMode.Default, verifier);
if (!verifier.Passed)
{
Assert.True(false, string.Format("Easy query {0} expected to run in parallel in default mode", i));
}
}
// Verify that all queries in 'easyQueries' always run in forced mode
for (int i = 0; i < easyQueries.Length; i++)
{
Verifier verifier = new ParVerifier();
easyQueries[i].Invoke(ParallelExecutionMode.ForceParallelism, verifier);
if (!verifier.Passed)
{
Assert.True(false, string.Format("Easy query {0} expected to run in parallel in force-parallelism mode", i));
}
}
// Verify that all queries in 'easyQueries' always run in forced mode
for (int i = 0; i < hardQueries.Length; i++)
{
Verifier verifier = new ParVerifier();
hardQueries[i].Invoke(ParallelExecutionMode.ForceParallelism, verifier);
if (!verifier.Passed)
{
Assert.True(false, string.Format("Hard query {0} expected to run in parallel in force-parallelism mode", i));
}
}
}
