如何在C#中的大数组上最大化元素操作的性能

Question

操作是将数组的每个第i个元素(称为A)和相同大小的矩阵的第i个元素(B)相乘,并使用获得的值更新A的相同第i个元素.

在算术公式中,A'[i] = A [i]*B [i](0 <i <n(A))

在多核环境中优化此操作的最佳方法是什么？

这是我目前的代码;

var learningRate = 0.001f;
var m = 20000;
var n = 40000;
var W = float[m*n]; 
var C = float[m*n];

//my current code ...[1]
Parallel.ForEach(Enumerable.Range(0, m), i =>
{
    for (int j = 0; j <= n - 1; j++)
    {
         W[i*n+j] *= C[i*n+j];
    }
});

//This is somehow far slower than [1], but I don't know why ... [2]
Parallel.ForEach(Enumerable.Range(0, n*m), i =>
{
    w[i] *= C[i]
});


//This is faster than [2], but not as fast as [1] ... [3]
for(int i = 0; i < m*n; i++)
{
    w[i] *= C[i]
}

测试了以下方法.但表现并没有变得更好. http://msdn.microsoft.com/en-us/library/dd560853.aspx

   public static void Test1()
    {
        Random rnd = new Random(1);

        var sw1 = new Stopwatch();
        var sw2 = new Stopwatch();
        sw1.Reset();
        sw2.Reset();

        int m = 10000;
        int n = 20000;
        int loops = 20;

        var W = DummyDataUtils.CreateRandomMat1D(m, n);
        var C = DummyDataUtils.CreateRandomMat1D(m, n);

        for (int l = 0; l < loops; l++)
        {
            var v = DummyDataUtils.CreateRandomVector(n);
            var b = DummyDataUtils.CreateRandomVector(m);

            sw1.Start();

            Parallel.ForEach(Enumerable.Range(0, m), i =>
            {
                for (int j = 0; j <= n - 1; j++)
                {
                    W[i*n+j] *= C[i*n+j];
                }
            });
            sw1.Stop();

            sw2.Start();
            // Partition the entire source array. 
            var rangePartitioner = Partitioner.Create(0, n*m);

            // Loop over the partitions in parallel.
            Parallel.ForEach(rangePartitioner, (range, loopState) =>
            {
                // Loop over each range element without a delegate invocation. 
                for (int i = range.Item1; i < range.Item2; i++)
                {
                    W[i] *= C[i];
                }
            });

            sw2.Stop();

            Console.Write("o");
        }

        var t1 = (double)sw1.ElapsedMilliseconds / loops;
        var t2 = (double)sw2.ElapsedMilliseconds / loops;

        Console.WriteLine("t1: " + t1);
        Console.WriteLine("t2: " + t2);
    }

---

结果:

t1:119

t2:120.4

Answer 1

问题在于，虽然调用委托相对较快，但当您多次调用它时，它就会增加，并且委托内部的代码非常简单。

您可以尝试使用 aPartitioner来指定要迭代的范围，这允许您为每个委托调用迭代许多项目（类似于您在 [1] 中所做的操作）：

Parallel.ForEach(Partitioner.Create(0, n * m), partition =>
    {
        for (int i = partition.Item1; i < partition.Item2; i++)
        {
            W[i] *= C[i];
        }
    });