作业一：并⾏矩阵乘法

描述

编写⼀个基于oneAPI的C++/SYCL程序来执行矩阵乘法操作。需要考虑大尺寸矩阵的乘法操作以及不同线程之 间的数据依赖关系。通常在实现矩阵乘法时，可以使用块矩阵乘法以及共享内存来提高计算效率。

分析

利用基于SYCL的编程模型在GPU上实现矩阵乘法的计算，步骤如下：

1. 分配内存：在主机端分配内存空间用于存储输⼊矩阵和输出矩阵，同时在GPU端分配内存空间用于存储相应 的输入和输出数据。

2. 数据传输：将输入矩阵数据从主机端内存传输到GPU端内存中。

3. 核函数调用：在SYCL中，矩阵乘法的计算通常会在GPU上使用核函数来实现并行计算。核函数 会分配线程块和线程来处理不同的数据块。

4. 并行计算：在核函数中，每个线程负责计算输出矩阵的⼀个单独的元素。为了最大限度地利用 GPU的并行计算能力，通常会使用⼆维线程块和线程网格的方式来处理矩阵的乘法计算。

5. 数据传输：计算完成后，将输出矩阵数据从GPU端内存传输回主机端内存中，以便进⼀步处理或 分析。

在并行计算矩阵乘法时，可以利用线程块和线程的层次结构来优化计算。通过合理划分矩阵数据并利用共享内 存来减少全局内存访问的次数，可以⼤幅提高计算效率。此外，还可以利用GPU上的多个计算单元并执行行矩 阵乘法，进⼀步提高计算速度。

作业解答：按点注释在代码中

#include <CL/sycl.hpp>
#include <iostream>
#include <random>
using namespace std;
using namespace sycl;
constexpr size_t M = 128;
constexpr size_t N = 256;
constexpr size_t K = 512;


int main() {
     // 1. 分配内存
    std::vector<float> matrixA(M * K, 2.0f); // 在主机端为输入矩阵 A 分配内存
    std::vector<float> matrixB(K * N, 3.0f); // 在主机端为输入矩阵 B 分配内存
    std::vector<float> matrixC(M * N, 0.0f); // 在主机端为输出矩阵 C 分配内存
 
    std::random_device rd;  
    std::mt19937 gen(rd()); 
    std::uniform_real_distribution<> dis(1.0, 100.0);

    // 使用随机数初始化输入矩阵
    for (size_t i = 0; i < M; ++i) {
        for (size_t j = 0; j < K; ++j) {
            matrixA[i * K + j] = dis(gen);
            //std::cout << matrixA[i * K + j] << " ";
        }
        //std::cout << std::endl;
    }
    for (size_t i = 0; i < K; ++i) {
        for (size_t j = 0; j < N; ++j) {
            matrixB[i * N + j] = dis(gen);
        }
    }

    sycl::queue myQueue;
{
    sycl::range<2> sizeA{M, K};
    sycl::range<2> sizeB{K, N};
    sycl::range<2> sizeC{M, N};
    sycl::buffer<float, 2> bufferA(matrixA.data(), sizeA);
    sycl::buffer<float, 2> bufferB(matrixB.data(), sizeB);
    sycl::buffer<float, 2> bufferC(matrixC.data(), sizeC);

    // 2. 数据传输：将输入矩阵数据从主机端内存传输到设备端内存中
    // 3. 核函数调用：在 SYCL 中，矩阵乘法的计算通常会在设备上使用核函数来实现并行计算
    myQueue.submit([&](sycl::handler& cgh) {
      auto accessorA = bufferA.get_access<sycl::access::mode::read>(cgh);
      auto accessorB = bufferB.get_access<sycl::access::mode::read>(cgh);
      auto accessorC = bufferC.get_access<sycl::access::mode::write>(cgh);
        sycl::range<2> globalRange{M, N};
        
        // 4. 并行计算：在核函数中，每个线程负责计算输出矩阵的一个单独的元素
        cgh.parallel_for<class MatrixMultiply>(globalRange, [=](sycl::id<2> idx) {

        float sum = 0.0f;
        for (int k = 0; k < K; ++k) {
          sum += accessorA[idx[0]][k] * accessorB[k][idx[1]];
        }
        accessorC[idx] = sum;
      });
    });
}
    myQueue.wait();

    // 5. 数据传输：计算完成后，将输出矩阵数据从设备端内存传输回主机端内存中
    // 打印结果
   for (size_t i = 0; i < M; ++i) {
        for (size_t j = 0; j < N; ++j) {
            std::cout << matrixC[i * N + j] << " ";
        }
        std::cout << std::endl;
    }

  return 0;
}

运行截图：