图像卷积并行加速

1 问题陈述

使用基于oneAPI的C++/SYCL实现一个用于计算图像的卷积操作。输⼊为一个图像矩阵和一个卷积核矩阵，输出为卷积后的图像。

2 项目简介

图像卷积是一种常见的图像处理操作，用于应用各种滤波器和特征检测器。其原理可以简单地描述为在图像的每个像素上应用一个小的矩阵（通常称为卷积核或滤波器），并将卷积核中的元素与图像中对应位置的像素值相乘，然后将所有乘积的和作为结果。这个过程可以看作是对图像进行了平滑、锐化、边缘检测等操作。

假设有⼀个大小为M×N的输入图像I和一个大小为m×n的卷积核K。图像卷积操作可以用下面的数学公式来表示：

其中，S(i, j)是卷积操作的结果图像中位置(i, j)处的像素值。I(i + k, j + l)是图像中位置(i + k, j + l)处的像素值，K(k, l)是卷积核中位置(k, l)处的权重。卷积核通常是一个小的⼆维矩阵，用于捕捉图像中的特定特征。

在异构计算编程中，可以使用并行计算来加速图像卷积操作。通过将图像分割成小块，然后在GPU上并行处理这些块，可以实现高效的图像卷积计算。通过合理的块大小和线程组织方式，可以最大限度地利用GPU的并行计算能力来加速图像处理过程。

基于GPU的图像卷积操作的原理基于并行处理和矩阵乘法的基本原理，通过将图像数据和卷积核数据分配给不同的线程块和线程，利用GPU的并行计算能力实现对图像的快速处理。

3 基本思路

1. 准备工作

导入SYCL头文件：引入SYCL相关的头文件，确保环境已配置好SYCL的开发环境。

读取图像：读取图像矩阵。

2. 定义内核函数

编写卷积内核：创建一个SYCL内核函数，其中包含卷积运算的算法。内核函数的输入参数包括输入图像、卷积核以及输出图像。

指定全局和局部大小：在内核函数中，指定全局和局部大小，以便在不同设备上执行时能够有效地利用并行性。

3. 数据传输

将输入数据传输到设备：使用SYCL的队列和缓冲区，将输入图像和卷积核数据传输到计算设备上。

4. 执行内核函数

启动内核函数：使用SYCL的队列，将内核函数提交到计算设备上执行。确保指定的全局和局部大小适应图像的尺寸和设备的处理能力。

在内核中进行卷积计算：在内核函数中，使用全局和局部ID来确定当前工作项的位置，然后执行卷积计算。

5. 将结果传回主机

将结果传回主机：使用SYCL的队列和缓冲区，将计算得到的输出图像矩阵传回主机内存。

6. 后处理

保存或显示结果：将输出矩阵保存到文件或在应用程序中显示，以便后续分析或可视化。

7. 释放资源

释放内存：在程序结束时，确保释放在计算设备上分配的内存和其他资源。

4 核心代码

#include <CL/sycl.hpp>

#include <iostream>

#include <fstream>

#include <vector>

#include <sstream>

#include <string>

#include <time.h>



using namespace sycl;



void read_file(std::string file_name, std::vector<std::vector<double>> &matrix)

{



    std::ifstream file(file_name);

    if (!file.is_open())

    {

        std::cerr << "can't open file" << std::endl;

    }



    std::string line;

    while (std::getline(file, line))

    {

        std::vector<double> row;

        std::istringstream lineStream(line);

        double value;



        while (lineStream >> value)

        {

            row.push_back(value);

        }

        matrix.push_back(row);

    }



    file.close();

}



int main()

{

    queue q;

    device my_device = q.get_device();



    std::vector<std::vector<double>> matrix;

    std::vector<std::vector<double>> kernel;



    std::string matrix_file = "matrix.txt";

    std::string kernel_file = "kernel.txt";



    read_file(matrix_file, matrix);

    read_file(kernel_file, kernel);



    // printf("%d %d", matrix1.size(), matrix2.size());

    int matrix_row = matrix.size();

    int matrix_col = matrix[0].size();

    int kernel_row = kernel.size();

    int kernel_col = kernel[0].size();



    int row = matrix_row - kernel_row + 1;

    int col = matrix_col - kernel_col + 1;



    std::vector<std::vector<double>> result(row, std::vector<double>(col));



    int start1 = clock();



    //     for (int i = 0; i < row; i++)

    //     {

    //         for (int j = 0; j < col; j++)

    //         {

    //             double ans = 0;

    //             for (int m = 0; m < kernel_row; m++)

    //             {

    //                 for (int n = 0; n < kernel_col; n++)

    //                 {

    //                     ans += matrix[i + m][j + n] * kernel[m][n];

    //                 }

    //             }

    //             result[i][j] = ans;

    //         }

    //     }



    int finish1 = clock();



    int start2 = clock();



    {

        buffer bufMatrix{matrix}, bufKernel{kernel}, bufResult{result};

        q.submit([&](handler &h)

                 {

        auto matrix = bufMatrix.get_access(h, read_only);

        auto kernel = bufKernel.get_access(h, read_only);

        auto result = bufResult.get_access(h, write_only);

        h.parallel_for(range<2>(row, col), [=](id<2> index) {

                int i = index[0];

                int j = index[1];

                for(int m = 0; m < kernel_row; m++) {

                   for(int n = 0; n < kernel_col; n++) {

                        result[i][j] += double(matrix[i + m][j + n] * kernel[m][n]);



                   }

                }

        }); });

    }



    int finish2 = clock();



    for (int i = 0; i < row; i++)

    {

        for (int j = 0; j < col; j++)

        {

            printf("%.4f ", result[i][j]);

        }

        printf("\n");

    }



    printf("in parallel compute:%f\n", (double)(finish2 - start2) / CLOCKS_PER_SEC);



    printf("in direct compute:%f\n", (double)(finish1 - start1) / CLOCKS_PER_SEC);



    return 0;

}

5 总结

SYCL的单一源代码编程模型为图像卷积操作提供了高度可移植的解决方案，使开发者能够在不同计算设备上实现并行加速，包括CPU、GPU等。通过内核函数的并行执行，数据传输和内存管理的抽象，以及性能优化和调试工具的支持，SYCL为图像卷积带来了更高效的计算方式，拓展了其应用领域，为实时图像处理、计算机视觉和深度学习等领域提供了潜在的性能提升和应用前景。