Intel oneAPI 是英特尔推出的一个综合性的软件开发工具套件，旨在支持跨不同体系结构的高性能计算和数据分析应用程序的开发。oneAPI 提供了一套统一的编程模型和工具，使开发人员能够利用英特尔的各种硬件和技术来实现高效的并行计算。
oneAPI 的主要特点和组成部分包括：
-
统一编程模型：oneAPI 提供了一种统一的编程模型，称为 Data Parallel C++（DPC++），它基于 SYCL（一种开放的异构编程标准）和其他标准（如C++和OpenCL）。DPC++允许开发人员使用单一代码库来编写可以在不同类型的硬件上执行的应用程序。
-
英特尔体系结构支持：oneAPI 支持英特尔的各种体系结构，包括 CPU、GPU、FPGA 和其他加速器。开发人员可以利用这些硬件的并行计算能力来加速应用程序的执行。
-
oneAPI 库：oneAPI 提供了一系列优化的数学、数据分析和机器学习库，如 oneMKL、oneDAL 和 oneDNN。这些库提供了高度优化的算法和函数，可用于加速各种计算任务。
-
oneAPI 工具集：oneAPI 提供了一套强大的开发工具，包括编译器、调试器、性能分析器和优化工具。这些工具可以帮助开发人员进行代码优化、调试和性能分析，以充分利用硬件的性能潜力。
-
社区支持和资源：oneAPI 社区提供了丰富的文档、示例代码和教程，以帮助开发人员快速上手并解决问题。开发人员还可以与一系列专家和其他开发人员交流，分享经验和解决方案。
实验步骤：
1：注册inter账号，进入DevCloud平台的在线Jupyter Lab环境，具体操作见DevCloud使用指南。
2：进入oneAPI_Essentials/02_SYCL_Program_Structure/目录，进入SYCL_Program_Structure.ipynb页面
3：找到Lab Exercise:Vector Add实验，在平台提供的代码编辑页面实现矩阵乘法算法并提交运行，自行检测算法是否正确
代码展示：
#include <chrono>
#include <iostream>
#include <CL/sycl.hpp>
#define random_float() (rand() / double(RAND_MAX))
using namespace std;
using namespace sycl;
// return execution time
double gpu_kernel(float *A, float *B, float *C, int M, int N, int K, int block_size, sycl::queue &q) {
// define the workgroup size and mapping
auto grid_rows = (M + block_size - 1) / block_size * block_size;
auto grid_cols = (N + block_size - 1) / block_size * block_size;
auto local_ndrange = range<2>(block_size, block_size);
auto global_ndrange = range<2>(grid_rows, grid_cols);
double duration = 0.0f;
auto e = q.submit([&](sycl::handler &h) {
h.parallel_for<class k_name_t>(
sycl::nd_range<2>(global_ndrange, local_ndrange), [=](sycl::nd_item<2> index) {
int row = index.get_global_id(0);
int col = index.get_global_id(1);
float sum = 0.0f;
for (int i = 0; i < K; i++) {
sum += A[row * K + i] * B[i * N + col];
}
C[row * N + col] = sum;
});
});
e.wait();
duration += (e.get_profiling_info<info::event_profiling::command_end>() -
e.get_profiling_info<info::event_profiling::command_start>()) /1000.0f/1000.0f;
return(duration);
}
// return execution time
double cpu_kernel(float *cA, float *cB, float *cC, int M, int N, int K) {
double duration = 0.0;
std::chrono::high_resolution_clock::time_point s, e;
// Single Thread Computation in CPU
s = std::chrono::high_resolution_clock::now();
for(int i = 0; i < M; i++) {
for(int j = 0; j < N; j++) {
float sum = 0.0f;
for(int k = 0; k < K; k++) {
sum += cA[i * K + k] * cB[k * N + j];
}
cC[i * N + j] = sum;
}
}
e = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration<float, std::milli>(e - s).count();
return(duration);
}
int verify(float *cpu_res, float *gpu_res, int length){
int err = 0;
for(int i = 0; i < length; i++) {
if( fabs(cpu_res[i] - gpu_res[i]) > 1e-3) {
err++;
printf("\n%lf, %lf", cpu_res[i], gpu_res[i]);
}
}
return(err);
}
int gemm(const int M,
const int N,
const int K,
const int block_size,
const int iterations,
sycl::queue &q) {
cout << "Problem size: c(" << M << "," << N << ") ="
<< " a(" << M << "," << K << ") *"
<< " b(" << K << "," << N << ")\n";
auto A = malloc_shared<float>(M * K, q);
auto B = malloc_shared<float>(K * N, q);
auto C = malloc_shared<float>(M * N, q);
auto C_host = malloc_host<float>(M * N, q);
// init the A/B/C
for(int i=0; i < M * K; i++) {
A[i] = random_float();
}
for(int i=0; i < K * N; i++) {
B[i] = random_float();
}
for(int i=0; i < M * N; i++) {
C[i] = 0.0f;
C_host[i] = 0.0f;
}
double flopsPerMatrixMul
= 2.0 * static_cast<double>(M) * static_cast<double>(N) * static_cast<double>(K);
double duration_gpu = 0.0f;
double duration_cpu = 0.0f;
// GPU compuation and timer
int warmup = 10;
for (int run = 0; run < iterations + warmup; run++) {
float duration = gpu_kernel(A, B, C, M, N, K, block_size, q);
if(run >= warmup) duration_gpu += duration;
}
duration_gpu = duration_gpu / iterations;
// CPU compuation and timer
warmup = 2;
for(int run = 0; run < iterations/2 + warmup; run++) {
float duration = cpu_kernel(A, B, C_host, M, N, K);
if(run >= warmup) duration_cpu += duration;
}
duration_cpu = duration_cpu / iterations/2;
// Compare the resutls of CPU and GPU
int errCode = 0;
errCode = verify(C_host, C, M*N);
if(errCode > 0) printf("\nThere are %d errors\n", errCode);
printf("\nPerformance Flops = %lf, \n"
"GPU Computation Time = %lf (ms); \n"
"CPU Computaiton Time = %lf (ms); \n",
flopsPerMatrixMul, duration_gpu, duration_cpu);
free(A, q);
free(B, q);
free(C, q);
free(C_host, q);
return(errCode);
}
int main() {
auto propList = cl::sycl::property_list {cl::sycl::property::queue::enable_profiling()};
queue my_gpu_queue( cl::sycl::gpu_selector_v , propList);
int errCode = gemm(1024, 1024, 1024, 4, 10, my_gpu_queue);
return(errCode);
}
代码介绍：
这个程序是一个使用SYCL实现的矩阵乘法（GEMM）的示例。它包含了在GPU上执行的核函数和在CPU上执行的串行版本。以下是对程序的简要介绍：
-
gpu_kernel函数：该函数定义了在GPU上执行的核函数。它使用SYCL的parallel_for和nd_range来定义全局大小和工作组大小，并在每个工作项中执行矩阵乘法运算。 -
cpu_kernel函数：该函数定义了在CPU上执行的串行版本。它使用嵌套的循环来计算矩阵乘法。 -
verify函数：该函数用于验证CPU和GPU计算的结果是否一致。它比较两个矩阵中的元素，并返回错误的数量。 -
gemm函数：该函数是程序的主要函数，它调用了gpu_kernel和cpu_kernel函数，并比较它们的执行时间和计算结果。它还初始化输入矩阵，并在GPU上分配共享和主机内存来存储矩阵数据。 -
main函数：该函数创建一个SYCL队列，并调用gemm函数来执行矩阵乘法计算。它使用GPU选择器来选择一个GPU设备，并启用性能分析特性。
整个程序的执行流程如下：
- 初始化输入矩阵A和B的随机值。
- 在GPU上执行矩阵乘法核函数，并记录执行时间。
- 在CPU上执行串行版本的矩阵乘法，并记录执行时间。
- 验证CPU和GPU计算的结果是否一致。
- 输出性能指标，包括每秒浮点运算次数（FLOPs）和GPU和CPU的计算时间。
- 参考资料来源：
- https://github.com/pengzhao-intel/oneAPI_course/blob/main/code/gemm_basic.cpp
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
