0

我正在尝试以顺序和并行方式实现 Strassen 矩阵乘法算法。我希望以下代码并行运行，但我没有并行编程经验。

int[][] M1 = multiply(add(A11, A22), add(B11, B22));
int[][] M2 = multiply(add(A21, A22), B11);
int[][] M3 = multiply(A11, sub(B12, B22));
int[][] M4 = multiply(A22, sub(B21, B11));
int[][] M5 = multiply(add(A11, A12), B22);
int[][] M6 = multiply(sub(A21, A11), add(B11, B12));
int[][] M7 = multiply(sub(A12, A22), add(B21, B22));

我在网上搜索并找到了可能的解决方案并重新排列了代码：

ExecutorService executor = Executors.newCachedThreadPool();
List<FutureTask<int[][]>> taskList1 = new ArrayList<FutureTask<int[][]>>();
// Start thread for the first half of the numbers
FutureTask<int[][]> futureTask_2 = new FutureTask<int[][]>(new Callable<int[][]>() {
    @Override
    public int[][] call() throws InterruptedException, ExecutionException {
        return multiply(add(A11, A22), add(B11, B22));
    }
});
FutureTask<int[][]> futureTask_3 = new FutureTask<int[][]>(new Callable<int[][]>() {
    @Override
    public int[][] call() throws InterruptedException, ExecutionException {
        return multiply(add(A21, A22), B11);
    }
});
FutureTask<int[][]> futureTask_4 = new FutureTask<int[][]>(new Callable<int[][]>() {
    @Override
    public int[][] call() throws InterruptedException, ExecutionException {
        return multiply(A11, sub(B12, B22));
    }
});
FutureTask<int[][]> futureTask_5 = new FutureTask<int[][]>(new Callable<int[][]>() {
    @Override
    public int[][] call() throws InterruptedException, ExecutionException {
        return multiply(A22, sub(B21, B11));
    }
});
FutureTask<int[][]> futureTask_6 = new FutureTask<int[][]>(new Callable<int[][]>() {
    @Override
    public int[][] call() throws InterruptedException, ExecutionException {
        return multiply(add(A11, A12), B22);
    }
});
FutureTask<int[][]> futureTask_7 = new FutureTask<int[][]>(new Callable<int[][]>() {
    @Override
    public int[][] call() throws InterruptedException, ExecutionException {
        return multiply(sub(A21, A11), add(B11, B12));
    }
});
FutureTask<int[][]> futureTask_8 = new FutureTask<int[][]>(new Callable<int[][]>() {
    @Override
    public int[][] call() throws InterruptedException, ExecutionException {
        return multiply(sub(A12, A22), add(B21, B22));
    }
});
taskList1.add(futureTask_2);
taskList1.add(futureTask_3);
taskList1.add(futureTask_4);
taskList1.add(futureTask_5);
taskList1.add(futureTask_6);
taskList1.add(futureTask_7);
taskList1.add(futureTask_8);
executor.execute(futureTask_2);
executor.execute(futureTask_3);
executor.execute(futureTask_4);
executor.execute(futureTask_5);
executor.execute(futureTask_6);
executor.execute(futureTask_7);
executor.execute(futureTask_8);

FutureTask<int[][]> ftrTask = taskList1.get(0);
final int[][] M1 = ftrTask.get();
FutureTask<int[][]> ftrTask1 = taskList1.get(1);
final int[][] M2 = ftrTask1.get();
FutureTask<int[][]> ftrTask2 = taskList1.get(2);
final int[][] M3 = ftrTask2.get();
FutureTask<int[][]> ftrTask3 = taskList1.get(3);
final int[][] M4 = ftrTask3.get();
FutureTask<int[][]> ftrTask4 = taskList1.get(4);
final int[][] M5 = ftrTask4.get();
FutureTask<int[][]> ftrTask5 = taskList1.get(5);
final int[][] M6 = ftrTask5.get();
FutureTask<int[][]> ftrTask6 = taskList1.get(6);
final int[][] M7 = ftrTask6.get();

executor.shutdown();

当我为少量数组维度（如 2、4、8、16）运行程序时，它的工作时间几乎与顺序版本相同。对于像 100、1000 这样的大尺寸，它计算结果的时间比顺序版本要长得多。我的并行实现错了吗？

4

0 回答 0