oneAPI 学习日志 02

graph TD
    UserApp["你的应用程序"] --> oneMKL["oneMKL (矩阵/FFT)"]
    UserApp --> AI_Frame["AI 框架 (PyTorch/OpenVINO)"]
    AI_Frame --> oneDNN["oneDNN (深度学习算子)"]
    UserApp --> oneTBB["oneTBB (CPU 多线程)"]
    
    oneMKL & oneDNN & oneTBB --> SYCL["SYCL / DPC++ Runtime"]
    SYCL --> Hardwares["CPU / GPU / FPGA / 加速器"]

#include <sycl/sycl.hpp>
#include <oneapi/mkl.hpp>
#include <iostream>

int main() {
    // 1. 指定在 GPU 上运行
    sycl::queue q{sycl::gpu_selector_v};
    std::cout << "Running MKL GEMM on: " 
              << q.get_device().get_info<sycl::info::device::name>() << "\n";

    // 矩阵维度：A(M, K) * B(K, N) = C(M, N)
    const int M = 4;
    const int N = 4;
    const int K = 4;

    // 2. 分配 USM 共享内存
    float* A = sycl::malloc_shared<float>(M * K, q);
    float* B = sycl::malloc_shared<float>(K * N, q);
    float* C = sycl::malloc_shared<float>(M * N, q);

    // 3. 初始化矩阵数据
    for (int i = 0; i < M * K; ++i) A[i] = 1.0f; // A 矩阵全 1.0
    for (int i = 0; i < K * N; ++i) B[i] = 2.0f; // B 矩阵全 2.0
    for (int i = 0; i < M * N; ++i) C[i] = 0.0f; // C 矩阵全 0.0

    // 4. 调用 oneMKL 的 GEMM 接口 (行优先布局)
    // 计算公式为: C = alpha * A * B + beta * C
    auto gemm_event = oneapi::mkl::blas::row_major::gemm(
        q, 
        oneapi::mkl::transpose::nontrans, // A 矩阵不转置
        oneapi::mkl::transpose::nontrans, // B 矩阵不转置
        M, N, K,
        1.0f,    // alpha
        A, K,    // A 指针，和它的 Leading Dimension (列数)
        B, N,    // B 指针，和它的 Leading Dimension (列数)
        0.0f,    // beta
        C, N     // C 指针，和它的 Leading Dimension (列数)
    );

    // 5. 等待 GPU 计算完成
    gemm_event.wait();

    // 6. 输出验证结果 (由于是全1矩阵乘全2矩阵，结果应全是 1*2*4 = 8.0)
    std::cout << "Result Matrix C:\n";
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            std::cout << C[i * N + j] << " ";
        }
        std::cout << "\n";
    }

    // 7. 释放内存
    sycl::free(A, q);
    sycl::free(B, q);
    sycl::free(C, q);

    return 0;
}

#include <sycl/sycl.hpp>
#include <oneapi/dnnl/dnnl.hpp>
#include <oneapi/dnnl/dnnl_sycl.hpp>
#include <iostream>

using namespace dnnl;

int main() {
    // 1. 创建 SYCL 队列 (指定 GPU)
    sycl::queue q{sycl::gpu_selector_v};
    std::cout << "Running oneDNN ReLU on: " 
              << q.get_device().get_info<sycl::info::device::name>() << "\n";

    // 2. 创建基于 SYCL 队列的 oneDNN engine 与 stream
    engine eng = dnnl::sycl_interop::make_engine(q.get_device(), q.get_context());
    stream strm = dnnl::sycl_interop::make_stream(eng, q);

    const int N = 8;
    // 3. 分配 USM 共享内存
    float* src_data = sycl::malloc_shared<float>(N, q);
    float* dst_data = sycl::malloc_shared<float>(N, q);

    // 初始化测试数据（包含正数和负数）
    float raw_src[] = {-3.0f, -1.5f, 0.0f, 2.0f, -0.5f, 4.0f, 1.0f, -2.0f};
    for (int i = 0; i < N; ++i) src_data[i] = raw_src[i];

    // 4. 创建 memory descriptor 和 memory 对象
    memory::dims dims = {N};
    memory::desc mem_d(dims, memory::data_type::f32, memory::format_tag::a);

    // 使用 SYCL interop 接口将 USM 内存封装为 oneDNN memory
    memory src_mem = dnnl::sycl_interop::make_memory(mem_d, eng, dnnl::sycl_interop::memory_kind::usm, src_data);
    memory dst_mem = dnnl::sycl_interop::make_memory(mem_d, eng, dnnl::sycl_interop::memory_kind::usm, dst_data);

    // 5. 创建 eltwise (ReLU) 算子描述符并实例化 Primitive
    auto eltwise_d = eltwise_forward::primitive_desc(
        eng, prop_kind::forward_inference, algorithm::eltwise_relu,
        mem_d, mem_d, 0.0f, 0.0f
    );
    auto eltwise_p = eltwise_forward(eltwise_d);

    // 6. 在 SYCL stream 上提交并执行算子
    eltwise_p.execute(strm, {{DNNL_ARG_SRC, src_mem}, {DNNL_ARG_DST, dst_mem}});
    strm.wait();

    // 7. 验证输出结果
    std::cout << "Input:  ";
    for (int i = 0; i < N; ++i) std::cout << raw_src[i] << "\t";
    std::cout << "\nReLU:   ";
    for (int i = 0; i < N; ++i) std::cout << dst_data[i] << "\t";
    std::cout << "\n";

    sycl::free(src_data, q);
    sycl::free(dst_data, q);
    return 0;
}

#include <tbb/parallel_for.h>
#include <tbb/blocked_range.h>
#include <iostream>
#include <vector>

int main() {
    const size_t N = 1000000;
    std::vector<int> vec(N);

    // 使用 oneTBB 的 parallel_for 在 CPU 多核心上自动切分区块并并行计算
    tbb::parallel_for(tbb::blocked_range<size_t>(0, N),
        [&](const tbb::blocked_range<size_t>& r) {
            for (size_t i = r.begin(); i != r.end(); ++i) {
                vec[i] = static_cast<int>(i * 2);
            }
        }
    );

    std::cout << "oneTBB parallel initialization done.\n";
    std::cout << "vec[0] = " << vec[0] 
              << ", vec[500000] = " << vec[500000] 
              << ", vec[N-1] = " << vec[N-1] << "\n";

    return 0;
}