使用std::vector实现OpenCL矩阵乘法

#include <iostream>
#include <vector>
#include <CL/cl.hpp>

// 定义矩阵乘法的函数
std::vector<float> matrixMultiplication(const std::vector<float>& matrixA, const std::vector<float>& matrixB, int rowsA, int colsA, int colsB) {
    std::vector<float> result(rowsA * colsB, 0.0f);

    // 获取OpenCL平台
    std::vector<cl::Platform> platforms;
    cl::Platform::get(&platforms);
    cl::Platform platform = platforms[0];

    // 获取设备
    std::vector<cl::Device> devices;
    platform.getDevices(CL_DEVICE_TYPE_GPU, &devices);
    cl::Device device = devices[0];

    // 创建上下文和命令队列
    cl::Context context(device);
    cl::CommandQueue queue(context, device);

    // 创建内存对象
    cl::Buffer bufferA(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float) * matrixA.size(), const_cast<float*>(matrixA.data()));
    cl::Buffer bufferB(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, sizeof(float) * matrixB.size(), const_cast<float*>(matrixB.data()));
    cl::Buffer bufferResult(context, CL_MEM_WRITE_ONLY, sizeof(float) * result.size());

    // 创建内核程序
    cl::Program::Sources sources;
    std::string kernelCode = R"(
        __kernel void matrixMultiplication(__global const float* matrixA, __global const float* matrixB, __global float* result, int rowsA, int colsA, int colsB) {
            int row = get_global_id(0);
            int col = get_global_id(1);

            float sum = 0.0f;
            for (int k = 0; k < colsA; ++k) {
                sum += matrixA[row * colsA + k] * matrixB[k * colsB + col];
            }

            result[row * colsB + col] = sum;
        }
    )";
    sources.push_back({kernelCode.c_str(), kernelCode.length()});

    cl::Program program(context, sources);
    program.build({device});

    // 创建内核
    cl::Kernel kernel(program, "matrixMultiplication");

    // 设置内核参数
    kernel.setArg(0, bufferA);
    kernel.setArg(1, bufferB);
    kernel.setArg(2, bufferResult);
    kernel.setArg(3, rowsA);
    kernel.setArg(4, colsA);
    kernel.setArg(5, colsB);

    // 执行内核
    cl::NDRange globalSize(rowsA, colsB);
    cl::NDRange localSize(1, 1);
    queue.enqueueNDRangeKernel(kernel, cl::NullRange, globalSize, localSize);

    // 读取结果
    queue.enqueueReadBuffer(bufferResult, CL_TRUE, 0, sizeof(float) * result.size(), result.data());

    return result;
}

int main() {
    // 创建两个矩阵
    int rowsA = 2;
    int colsA = 3;
    int colsB = 3;

    std::vector<float> matrixA = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f};
    std::vector<float> matrixB = {7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};

    // 执行矩阵乘法
    std::vector<float> result = matrixMultiplication(matrixA, matrixB, rowsA, colsA, colsB);

    // 输出结果
    for (int i = 0; i < rowsA; ++i) {
        for (int j = 0; j < colsB; ++j) {
            std::cout << result[i * colsB + j] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}