Question

我尝试实现Cannon的矩阵乘法算法。我阅读了提供下一个伪代码的wikipedia的描述：

   row i of matrix a is circularly shifted by i elements to the left.
   col j of matrix b is circularly shifted by j elements up.
   Repeat n times:
       p[i][j] multiplies its two entries and adds to running total.
       circular shift each row of a 1 element left
       circular shift each col of b 1 element up

我在下一个C＃上实现了它：

    public static void ShiftLeft(int[][] matrix, int i, int count)
    {
        int ind = 0;
        while (ind < count)
        {
            int temp = matrix[i][0];
            int indl = matrix[i].Length - 1;
            for (int j = 0; j < indl; j++)
                matrix[i][j] = matrix[i][j + 1];
            matrix[i][indl] = temp;
            ind++;
        }
    }
    public static void ShiftUp(int[][] matrix, int j, int count)
    {
        int ind = 0;
        while (ind < count)
        {
            int temp = matrix[0][j];
            int indl = matrix.Length - 1;
            for (int i = 0; i < indl; i++)
                matrix[i][j] = matrix[i + 1][j];
            matrix[indl][j] = temp;
            ind++;
        }
    }

    public static int[][] Cannon(int[][] A, int[][] B)
    {
        int[][] C = new int[A.Length][];
        for (int i = 0; i < C.Length; i++)
            C[i] = new int[A.Length];
        for (int i = 0; i < A.Length; i++)
            ShiftLeft(A, i, i);

        for (int i = 0; i < B.Length; i++)
            ShiftUp(B, i, i);

        for (int k = 0; k < A.Length; k++)
        {
            for (int i = 0; i < A.Length; i++)
            {
                for (int j = 0; j < B.Length; j++)
                {
                    var m = (i + j + k) % A.Length;
                    C[i][j] += A[i][m] * B[m][j];
                    ShiftLeft(A, i, 1);
                    ShiftUp(B, j, 1);
                }

            }
        };

        return C;

    }

此代码返回正确的结果，但执行速度非常慢。甚至比天真的矩阵乘法算法慢得多。

对于矩阵200x200，我得到了结果：

00:00:00.0490432 //naive algorithm
00:00:07.1397479 //Cannon's algorithm

我做错了什么？

修改

感谢SergeySlepov，尝试并行是不好的尝试。当我回到顺序实现时，我得到了下一个结果：

Count       Naive               Cannon's

200    00:00:00.0492098    00:00:08.0465076

250    00:00:00.0908136    00:00:22.3891375

300    00:00:00.1477764    00:00:58.0640621

350    00:00:00.2639114    00:01:51.5545524

400    00:00:00.4323984    00:04:50.7260942

好吧，它不是并行实现，但我该如何正确执行？

Answer 1

Cannon's algorithm专为＆＃39; Distributed Memory机器而设计。（处理器网格，每个处理器都有自己的内存）。这与您运行它的硬件（具有共享内存的几个处理器）非常不同，这就是您没有看到任何性能提升的原因。

＆＃39;循环移位＆＃39;您引用的伪代码实际上模仿处理器之间的数据传输。在初始矩阵“倾斜”之后，网格中的每个处理器跟踪三个数字（a，b和c）并执行与此类似的伪代码：

c += a * b;
pass 'a' to the processor to your left (wrapping around)
pass 'b' to the processor to 'above' you (wrapping around)
wait for the next iteration of k

我们可以在使用NxN线程的PC上模仿这种行为，但是上下文切换（或产生Task s）的开销会消除所有的快乐。为了充分利用PC的4个（或左右）CPU，我们可以使i并行循环。 k上的循环需要是顺序的（与您的解决方案不同），否则您可能会遇到竞争条件，因为k的每次迭代都会修改矩阵A，B和C.在分布式内存中机＆＃39;竞争条件不是问题，因为处理器不共享任何内存。

加农炮的矩阵乘法算法

修改

1 个答案: