基于Intel oneAPI的并行排序算法

目录

oneAPI简介

问题描述

问题分析

完整代码

总结

---

oneAPI简介

Intel oneAPI是Intel提供的统一编程模型和软件开发框架。 它旨在简化可充分利用英特尔各种硬件架构（包括 CPU、GPU 和 FPGA）的应用程序的开发。

oneAPI 提供了一组工具、库和框架，使开发人员能够编写跨不同硬件平台的高性能代码。 它支持多种编程语言，包括 C++、Fortran 和数据并行 C++ (DPC++)。 借助 oneAPI，开发人员可以使用熟悉的编程模型编写代码并针对不同的硬件架构，而无需对代码进行重大修改。它使用SYCL（C++异构计算标准）编程模型来表达并行性。

问题描述

使用基于oneAPI的C++/SYCL实现⼀个高效的并行归并排序。需要考虑数据的分割和合并以及线程之间的协作。

问题分析

归并排序是⼀种分治算法，其基本原理是将待排序的数组分成两部分，分别对这两部分进行排序，然后将已排 序的子数组合并为⼀个有序数组。可考虑利用了异构并行计算的特点，将排序和合并操作分配给多个线程同时 执行，以提高排序效率。具体实现过程如下：

1. 将待排序的数组分割成多个较小的子数组，并将这些⼦数组分配给不同的线程块进行处理。

2. 每个线程块内部的线程协作完成子数组的局部排序。

3. 通过多次迭代，不断合并相邻的有序⼦数组，直到整个数组有序。

在实际实现中，归并排序可使用共享内存来加速排序过程。具体来说，可以利用共享内存来存储临时数据，减 少对全局内存的访问次数，从而提高排序的效率。另外，在合并操作中，需要考虑同步机制来保证多个线程之 间的数据⼀致性。

需要注意的是，在实际应用中，要考虑到数组大小、线程块大小、数据访问模式等因素，来设计合适的算法和 参数设置，以充分利用目标计算硬件GPU的并行计算能力，提高排序的效率和性能。

完整代码

#include <iostream>
#include <fstream>
#include <sstream>
#include <cmath>
#include <vector>
#include <CL/sycl.hpp>
#include "dpc_common.hpp"

using namespace sycl;
using namespace std;

// 初始化数组
void initializeArr(vector<double>& arr, const string& line) {
    istringstream iss(line);
    double value;
    while (iss >> value) {
        arr.push_back(value);
    }
}

// 获取数组大小
int getSize(const string& line) {
    istringstream iss(line);
    double value;
    int size = 0;
    while (iss >> value) {
        size++;
    }
    return size;
}

// 获取n的值
int getN(int size) {
    int res = 1;
    int x = 2;
    while (x < size) {
        res++;
        x *= 2;
    }
    return res;
}

// 获取新的数组大小
int getNewSize(int n) {
    int res = 1;
    while (n--) {
        res *= 2;
    }
    return res;
}

// 并行比特位排序
void parallelBitonicSortBuffer(vector<double>& data_arr, int n, queue& q) {
    int size = pow(2, n);
    buffer<double, 1> input(data_arr.data(), range<1>(size));

    for (int step = 0; step < n; step++) {
        for (int stage = step; stage >= 0; stage--) {
            int seq_len = pow(2, stage + 1);
            int two_power = 1 << (step - stage);

            q.submit([&](handler& h) {
                auto a = input.get_access<access::mode::read_write>(h);

                h.parallel_for(range<1>(size), [=](id<1> i) {
                    int seq_num = i / seq_len;
                    int swapped_ele = -1;
                    int h_len = seq_len / 2;

                    if (i < (seq_len * seq_num) + h_len)
                        swapped_ele = i + h_len;

                    int odd = seq_num / two_power;
                    bool increasing = ((odd % 2) == 0);

                    if (swapped_ele != -1) {
                        if (((a[i] > a[swapped_ele]) && increasing) ||
                            ((a[i] < a[swapped_ele]) && !increasing)) {
                            double temp = a[i];
                            a[i] = a[swapped_ele];
                            a[swapped_ele] = temp;
                        }
                    }
                });
            });
        }
    }
}

// 显示数组
void displayArray(const vector<double>& arr) {
    for (const auto& elem : arr) {
        cout << elem << " ";
    }
    cout << "\n";
}

int main() {
    try {
        ifstream infile("problem-2.txt");
        string line;
        getline(infile, line);

        vector<double> data_arr;
        initializeArr(data_arr, line);

        int size = getSize(line);
        int n = getN(size);
        int newSize = getNewSize(n);

        cout << "\n数组大小: " << size << "\n";

        queue q;
        cout << "设备: " << q.get_device().get_info<info::device::name>() << "\n";

        data_arr.resize(newSize, 100000000); // 填充剩余部分

        // 开始计时
        dpc_common::TimeInterval t_par1;

        // 使用缓冲区分配的并行排序
        parallelBitonicSortBuffer(data_arr, n, q);

        cout << "使用缓冲区分配的内核时间: " << t_par1.Elapsed() << " 秒\n";

        ofstream outputFile("problem-2-result.txt");
        for (int i = 0; i < size - 1; i++) {
            outputFile << fixed << data_arr[i] << " ";
        }
        outputFile.close();
    } catch (const exception& e) {
        cerr << "发生异常: " << e.what() << "\n";
        return 1;
    }

    return 0;
}

总结

学习使用intel oneAPI实现了并行快速排序计算，学习使用oneAPI不仅能获得高效的计算性能，也可以帮助开发者更深入地理解并行编程和异构计算，同时提高对内存管理和性能优化的认识。这对于在高性能计算环境中进行编程是非常有价值的。