ufkc7e3d
/
mathnet-numerics
forked from tsai/mathnet-numerics
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

vector parallelization tweaks

la-knuth
Marcus Cuda 15 years ago
parent
2234560a7a
commit
57da4a187e
5 changed files with 314 additions and 52 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 86
      src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs
  2. 87
      src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs
  3. 87
      src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs
  4. 86
      src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs
  5. 20
      src/Numerics/Threading/CommonParallel.cs

86
src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs
View File

@ -71,11 +71,31 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
}
else if (alpha.IsOne())
{
CommonParallel.ElementFor(0, y.Length, y.Length, index => result[index] = y[index] + x[index]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = y[index] + x[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => result[index] = y[index] + x[index]);
}
}
else
{
CommonParallel.ElementFor(0, y.Length, y.Length, index => result[index] = y[index] + (alpha * x[index]));
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = y[index] + (alpha * x[index]);
}
}
else
{
CommonParallel.For(0, y.Length, index => result[index] = y[index] + (alpha * x[index]));
}
}
}
@ -103,7 +123,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
}
else
{
CommonParallel.ElementFor(0, x.Length, x.Length, index => { result[index] = alpha * x[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = alpha * x[index];
}
}
else
{
CommonParallel.For(0, x.Length, index => { result[index] = alpha * x[index]; });
}
}
}
@ -172,7 +202,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, i => result[i] = x[i] + y[i]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] + y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] + y[index]; });
}
}
/// <summary>
@ -207,7 +247,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, i => result[i] = x[i] - y[i]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] - y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] - y[index]; });
}
}
/// <summary>
@ -242,7 +292,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, i => result[i] = x[i] * y[i]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] * y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] * y[index]; });
}
}
/// <summary>
@ -277,7 +337,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, index => { result[index] = x[index] / y[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] / y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] / y[index]; });
}
}
/// <summary>
@ -1234,7 +1304,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
{
var tmpColCount = colLimit - firstCol;
if ((availableCores > 1) && (tmpColCount > 200))
if ((availableCores > 1) && (tmpColCount > Control.ParallelizeElements))
{
var tmpSplit = firstCol + (tmpColCount / 3);
var tmpCores = availableCores / 2;

87
src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs
View File

@ -65,12 +65,33 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
}
else if (alpha.IsOne())
{
CommonParallel.ElementFor(0, y.Length, y.Length, index => result[index] = y[index] + x[index]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = y[index] + x[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => result[index] = y[index] + x[index]);
}
}
else
{
CommonParallel.ElementFor(0, y.Length, y.Length, index => result[index] = y[index] + (alpha * x[index]));
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = y[index] + (alpha * x[index]);
}
}
else
{
CommonParallel.For(0, y.Length, index => result[index] = y[index] + (alpha * x[index]));
}
}
}
/// <summary>
@ -97,7 +118,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
}
else
{
CommonParallel.ElementFor(0, x.Length, x.Length, index => { result[index] = alpha * x[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = alpha * x[index];
}
}
else
{
CommonParallel.For(0, x.Length, index => { result[index] = alpha * x[index]; });
}
}
}
@ -167,7 +198,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, i => result[i] = x[i] + y[i]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] + y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] + y[index]; });
}
}
/// <summary>
@ -202,7 +243,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, i => result[i] = x[i] - y[i]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] - y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] - y[index]; });
}
}
/// <summary>
@ -237,7 +288,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, i => result[i] = x[i] * y[i]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] * y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] * y[index]; });
}
}
/// <summary>
@ -272,7 +333,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, index => { result[index] = x[index] / y[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] / y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] / y[index]; });
}
}
/// <summary>
@ -1229,7 +1300,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
{
var tmpColCount = colLimit - firstCol;
if ((availableCores > 1) && (tmpColCount > 200))
if ((availableCores > 1) && (tmpColCount > Control.ParallelizeElements))
{
var tmpSplit = firstCol + (tmpColCount / 3);
var tmpCores = availableCores / 2;

87
src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs
View File

@ -65,11 +65,31 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
}
else if (alpha == 1.0)
{
CommonParallel.ElementFor(0, y.Length, y.Length, index => result[index] = y[index] + x[index]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = y[index] + x[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => result[index] = y[index] + x[index]);
}
}
else
{
CommonParallel.ElementFor(0, y.Length, y.Length, index => result[index] = y[index] + (alpha * x[index]));
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = y[index] + (alpha * x[index]);
}
}
else
{
CommonParallel.For(0, y.Length, index => result[index] = y[index] + (alpha * x[index]));
}
}
}
@ -97,7 +117,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
}
else
{
CommonParallel.ElementFor(0, x.Length, x.Length, index => { result[index] = alpha * x[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = alpha * x[index];
}
}
else
{
CommonParallel.For(0, x.Length, index => { result[index] = alpha * x[index]; });
}
}
}
@ -167,7 +197,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, index => { result[index] = x[index] + y[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] + y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] + y[index]; });
}
}
/// <summary>
@ -202,7 +242,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, index => { result[index] = x[index] - y[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] - y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] - y[index]; });
}
}
/// <summary>
@ -237,7 +287,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, index => { result[index] = x[index] * y[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] * y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] * y[index]; });
}
}
/// <summary>
@ -272,7 +332,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, index => { result[index] = x[index] / y[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] / y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] / y[index]; });
}
}
/// <summary>
@ -1119,7 +1189,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
{
var tmpColCount = colLimit - firstCol;
if ((availableCores > 1) && (tmpColCount > 200))
if ((availableCores > 1) && (tmpColCount > Control.ParallelizeElements))
{
var tmpSplit = firstCol + (tmpColCount / 3);
var tmpCores = availableCores / 2;
@ -1207,6 +1277,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentReferenceDifferent);
}
if( )
CommonParallel.For(
0,
columnsB,

86
src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs
View File

@ -65,11 +65,31 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
}
else if (alpha == 1.0)
{
CommonParallel.ElementFor(0, y.Length, y.Length, index => result[index] = y[index] + x[index]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = y[index] + x[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => result[index] = y[index] + x[index]);
}
}
else
{
CommonParallel.ElementFor(0, y.Length, y.Length, index => result[index] = y[index] + (alpha * x[index]));
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = y[index] + (alpha * x[index]);
}
}
else
{
CommonParallel.For(0, y.Length, index => result[index] = y[index] + (alpha * x[index]));
}
}
}
@ -97,7 +117,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
}
else
{
CommonParallel.ElementFor(0, x.Length, x.Length, index => { result[index] = alpha * x[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = alpha * x[index];
}
}
else
{
CommonParallel.For(0, x.Length, index => { result[index] = alpha * x[index]; });
}
}
}
@ -167,7 +197,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, i => result[i] = x[i] + y[i]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] + y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] + y[index]; });
}
}
/// <summary>
@ -202,7 +242,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, i => result[i] = x[i] - y[i]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] - y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] - y[index]; });
}
}
/// <summary>
@ -237,7 +287,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, i => result[i] = x[i] * y[i]);
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] * y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] * y[index]; });
}
}
/// <summary>
@ -272,7 +332,17 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
throw new ArgumentException(Resources.ArgumentVectorsSameLength);
}
CommonParallel.ElementFor(0, y.Length, y.Length, index => { result[index] = x[index] / y[index]; });
if (x.Length < Control.ParallelizeElements || Control.DisableParallelization)
{
for (var index = 0; index < x.Length; index++)
{
result[index] = x[index] / y[index];
}
}
else
{
CommonParallel.For(0, y.Length, index => { result[index] = x[index] / y[index]; });
}
}
/// <summary>
@ -1120,7 +1190,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
{
var tmpColCount = colLimit - firstCol;
if ((availableCores > 1) && (tmpColCount > 200))
if ((availableCores > 1) && (tmpColCount > Control.ParallelizeElements))
{
var tmpSplit = firstCol + (tmpColCount / 3);
var tmpCores = availableCores / 2;

20
src/Numerics/Threading/CommonParallel.cs
View File

@ -42,26 +42,6 @@ namespace MathNet.Numerics.Threading
/// </summary>
public static class CommonParallel
{
/// <summary>
/// Executes a for loop in which iterations may run in parallel.
/// </summary>
/// <param name="fromInclusive">The start index, inclusive.</param>
/// <param name="toExclusive">The end index, exclusive.</param>
/// <param name="numberOfElements">The number of elements that will be iterated over.</param>
/// <param name="body">The body to be invoked for each iteration.</param>
/// <exception cref="ArgumentNullException">The <paramref name="body"/> argument is <c>null</c>.</exception>
/// <exception cref="AggregateException">At least one invocation of the body threw an exception.</exception>
public static void ElementFor(int fromInclusive, int toExclusive, int numberOfElements, Action<int> body)
{
var parallel = true;
if (Control.DisableParallelization || Control.NumberOfParallelWorkerThreads < 2 || numberOfElements < Control.ParallelizeElements)
{
parallel = false;
}
For(fromInclusive, toExclusive, body, parallel);
}
/// <summary>
/// Executes a for loop in which iterations may run in parallel.
/// </summary>

Write Preview
Loading…
Cancel
Save