[DFT][Examples] Make the oneMKL DFT example consistent with the other domains

examples/README.md

@@ -3,15 +3,14 @@ oneAPI Math Kernel Library (oneMKL) Interfaces offers examples with the followin
 - blas: level3/gemm_usm  
 - rng: uniform_usm  
 - lapack: getrs_usm
-- dft: complex_fwd_buffer, real_fwd_usm
+- dft: complex_fwd_usm, real_fwd_usm
 - sparse_blas: sparse_gemv_usm
 
 Each routine has one run-time dispatching example and one compile-time dispatching example (which uses both mklcpu and cuda backends), located in `example/<$domain>/run_time_dispatching` and `example/<$domain>/compile_time_dispatching` subfolders, respectively.
 
 To build examples, use cmake build option `-DBUILD_EXAMPLES=true`.  
 Compile_time_dispatching will be built if `-DBUILD_EXAMPLES=true` and cuda backend is enabled, because the compile-time dispatching example runs on both mklcpu and cuda backends.
 Run_time_dispatching will be built if `-DBUILD_EXAMPLES=true` and `-DBUILD_SHARED_LIBS=true`.
-All DFT examples require the mklgpu backend to be enabled.
 
 The example executable naming convention follows `example_<$domain>_<$routine>_<$backend>` for compile-time dispatching examples 
   or `example_<$domain>_<$routine>` for run-time dispatching examples. 

examples/dft/compile_time_dispatching/CMakeLists.txt

@@ -18,31 +18,35 @@
 #===============================================================================
 
 #Build object from all sources
-set(DFTI_CT_BACKENDS "")
-
-if(ENABLE_MKLGPU_BACKEND)
-  list(APPEND DFTI_CT_BACKENDS "mklgpu")
-endif()
-
-if(ENABLE_MKLCPU_BACKEND)
-  list(APPEND DFTI_CT_BACKENDS "mklcpu")
+set(DFT_CT_SOURCES "")
+if (ENABLE_MKLCPU_BACKEND AND ENABLE_CUFFT_BACKEND)
+  list(APPEND DFT_CT_SOURCES "complex_fwd_usm_mklcpu_cufft")
 endif()
 
 include(WarningsUtils)
 
-foreach(dfti_backend ${DFTI_CT_BACKENDS})
-  set(EXAMPLE_NAME example_dft_complex_fwd_buffer_${dfti_backend})
-  add_executable(${EXAMPLE_NAME} complex_fwd_buffer_${dfti_backend}.cpp)
+foreach(dft_ct_source ${DFT_CT_SOURCES})
+  set(EXAMPLE_NAME example_${domain}_${dft_ct_source})
+  add_executable(${EXAMPLE_NAME} ${dft_ct_source}.cpp)
   target_include_directories(${EXAMPLE_NAME}
       PUBLIC ${PROJECT_SOURCE_DIR}/examples/include
       PUBLIC ${PROJECT_SOURCE_DIR}/include
       PUBLIC ${CMAKE_BINARY_DIR}/bin
   )
 
-  add_dependencies(${EXAMPLE_NAME} onemkl_dft_${dfti_backend})
-  target_link_libraries(${EXAMPLE_NAME} PRIVATE ONEMKL::SYCL::SYCL onemkl_dft_${dfti_backend} onemkl_warnings)
+if(domain STREQUAL "dft" AND ENABLE_MKLCPU_BACKEND AND ENABLE_CUFFT_BACKEND)
+  add_dependencies(${EXAMPLE_NAME} onemkl_${domain}_mklcpu onemkl_${domain}_cufft)
+  list(APPEND ONEMKL_LIBRARIES_${domain} onemkl_${domain}_mklcpu onemkl_${domain}_cufft)
+endif()
+
+target_link_libraries(${EXAMPLE_NAME} PUBLIC
+  ${ONEMKL_LIBRARIES_${domain}}
+  ONEMKL::SYCL::SYCL
+  onemkl_warnings
+  )
 
   # Register example as ctest
-  add_test(NAME dft/EXAMPLE/CT/complex_fwd_buffer_${dfti_backend} COMMAND ${EXAMPLE_NAME})
-endforeach(dfti_backend)
+  add_test(NAME dft/EXAMPLE/CT/${dft_ct_source} COMMAND ${EXAMPLE_NAME})
+
+endforeach(dft_ct_source)
 

examples/dft/compile_time_dispatching/complex_fwd_buffer_mklgpu.cpp → examples/dft/compile_time_dispatching/complex_fwd_usm_mklcpu_cufft.cpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2023 Intel Corporation
+* Copyright 2024 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -27,10 +27,26 @@
 #include <CL/sycl.hpp>
 #endif
 #include "oneapi/mkl.hpp"
+#include <complex>
 
-void run_example(const sycl::device& gpu_device) {
+void run_example(const sycl::device& cpu_device, const sycl::device& gpu_device) {
     constexpr std::size_t N = 10;
 
+    // Catch asynchronous exceptions for cpu
+    auto cpu_error_handler = [&](sycl::exception_list exceptions) {
+        for (auto const& e : exceptions) {
+            try {
+                std::rethrow_exception(e);
+            }
+            catch (sycl::exception const& e) {
+                // Handle not dft related exceptions that happened during asynchronous call
+                std::cerr << "Caught asynchronous SYCL exception on CPU device during execution:"
+                          << std::endl;
+                std::cerr << "\t" << e.what() << std::endl;
+            }
+        }
+        std::exit(2);
+    };
     // Catch asynchronous exceptions for gpu
     auto gpu_error_handler = [&](sycl::exception_list exceptions) {
         for (auto const& e : exceptions) {
@@ -39,17 +55,30 @@ void run_example(const sycl::device& gpu_device) {
             }
             catch (sycl::exception const& e) {
                 // Handle not dft related exceptions that happened during asynchronous call
-                std::cerr << "Caught asynchronous SYCL exception:" << std::endl;
+                std::cerr << "Caught asynchronous SYCL exception on GPU device during execution:"
+                          << std::endl;
                 std::cerr << "\t" << e.what() << std::endl;
             }
         }
         std::exit(2);
     };
 
+    // Preparation CPU device and GPU device
+    sycl::queue cpu_queue(cpu_device, cpu_error_handler);
     sycl::queue gpu_queue(gpu_device, gpu_error_handler);
 
-    std::vector<std::complex<float>> input_data(N);
-    std::vector<std::complex<float>> output_data(N);
+    // allocate on CPU device and GPU device
+    auto cpu_input_data = sycl::malloc_shared<std::complex<float>>(N, cpu_queue);
+    auto cpu_output_data = sycl::malloc_shared<std::complex<float>>(N, cpu_queue);
+
+    auto gpu_input_data = sycl::malloc_shared<std::complex<float>>(N, gpu_queue);
+    auto gpu_output_data = sycl::malloc_shared<std::complex<float>>(N, gpu_queue);
+
+    // Initialize input data
+    for (std::size_t i = 0; i < N; ++i) {
+        cpu_input_data[i] = { static_cast<float>(i), static_cast<float>(-i) };
+        gpu_input_data[i] = { static_cast<float>(i), static_cast<float>(-i) };
+    }
 
     // enabling
     // 1. create descriptors
@@ -63,16 +92,27 @@ void run_example(const sycl::device& gpu_device) {
     desc.set_value(oneapi::mkl::dft::config_param::NUMBER_OF_TRANSFORMS,
                    static_cast<std::int64_t>(1));
 
-    // 3. commit_descriptor (compile_time MKLGPU)
-    desc.commit(oneapi::mkl::backend_selector<oneapi::mkl::backend::mklgpu>{ gpu_queue });
+    // 3a. commit_descriptor (compile_time MKLCPU)
+    desc.commit(oneapi::mkl::backend_selector<oneapi::mkl::backend::mklcpu>{ cpu_queue });
 
-    // 4. compute_forward / compute_backward (MKLGPU)
-    {
-        sycl::buffer<std::complex<float>> input_buffer(input_data.data(), sycl::range<1>(N));
-        sycl::buffer<std::complex<float>> output_buffer(output_data.data(), sycl::range<1>(N));
-        oneapi::mkl::dft::compute_forward<decltype(desc), std::complex<float>, std::complex<float>>(
-            desc, input_buffer, output_buffer);
-    }
+    // 4a. compute_forward / compute_backward (MKLCPU)
+    oneapi::mkl::dft::compute_forward<decltype(desc), std::complex<float>, std::complex<float>>(
+        desc, cpu_input_data, cpu_output_data);
+
+    // 3b. commit_descriptor (compile_time cuFFT)
+    desc.commit(oneapi::mkl::backend_selector<oneapi::mkl::backend::cufft>{ gpu_queue });
+
+    // 4b. compute_forward / compute_backward (cuFFT)
+    oneapi::mkl::dft::compute_forward<decltype(desc), std::complex<float>, std::complex<float>>(
+        desc, gpu_input_data, gpu_output_data);
+
+    cpu_queue.wait_and_throw();
+    gpu_queue.wait_and_throw();
+
+    sycl::free(cpu_input_data, cpu_queue);
+    sycl::free(gpu_input_data, gpu_queue);
+    sycl::free(cpu_output_data, cpu_queue);
+    sycl::free(gpu_output_data, gpu_queue);
 }
 
 //
@@ -81,18 +121,16 @@ void run_example(const sycl::device& gpu_device) {
 void print_example_banner() {
     std::cout << "\n"
                  "########################################################################\n"
-                 "# Complex out-of-place forward transform for Buffer API's example:\n"
+                 "# Complex out-of-place forward transform for USM API's example:\n"
                  "#\n"
                  "# Using APIs:\n"
                  "#   Compile-time dispatch API\n"
-                 "#   Buffer forward complex out-of-place\n"
+                 "#   USM forward complex out-of-place\n"
                  "#\n"
                  "# Using single precision (float) data type\n"
                  "#\n"
-                 "# For Intel GPU with Intel MKLGPU backend.\n"
+                 "# Running on both Intel CPU and NVIDIA GPU devices.\n"
                  "#\n"
-                 "# The environment variable ONEAPI_DEVICE_SELECTOR can be used to specify\n"
-                 "# available devices\n"
                  "########################################################################\n"
               << std::endl;
 }
@@ -104,15 +142,25 @@ int main(int /*argc*/, char** /*argv*/) {
     print_example_banner();
 
     try {
+        sycl::device cpu_device((sycl::cpu_selector_v));
         sycl::device gpu_device((sycl::gpu_selector_v));
-        std::cout << "Running DFT Complex forward out-of-place buffer example" << std::endl;
-        std::cout << "Using compile-time dispatch API with MKLGPU." << std::endl;
+
+        unsigned int vendor_id = gpu_device.get_info<sycl::info::device::vendor_id>();
+        if (vendor_id != NVIDIA_ID) {
+            std::cerr << "FAILED: NVIDIA GPU device not found" << std::endl;
+            return 1;
+        }
+
+        std::cout << "Running DFT Complex forward out-of-place usm example" << std::endl;
+        std::cout << "Using compile-time dispatch API with MKLCPU and cuFFT." << std::endl;
         std::cout << "Running with single precision real data type on:" << std::endl;
+        std::cout << "\tCPU device: " << cpu_device.get_info<sycl::info::device::name>()
+                  << std::endl;
         std::cout << "\tGPU device :" << gpu_device.get_info<sycl::info::device::name>()
                   << std::endl;
 
-        run_example(gpu_device);
-        std::cout << "DFT Complex USM example ran OK on MKLGPU" << std::endl;
+        run_example(cpu_device, gpu_device);
+        std::cout << "DFT Complex USM example ran OK on MKLCPU and CUFFT" << std::endl;
     }
     catch (sycl::exception const& e) {
         // Handle not dft related exceptions that happened during synchronous call

examples/dft/run_time_dispatching/CMakeLists.txt

@@ -27,13 +27,16 @@ set(DFT_RT_SOURCES "")
 # If users build more than one backend (i.e. mklcpu and mklgpu, or mklcpu and CUDA), they may need to
 # overwrite ONEAPI_DEVICE_SELECTOR in their environment to run on the desired backend
 set(DEVICE_FILTERS "")
-if(ENABLE_MKLGPU_BACKEND OR ENABLE_CUFFT_BACKEND OR ENABLE_ROCFFT_BACKEND OR ENABLE_PORTFFT_BACKEND)
+if(ENABLE_MKLGPU_BACKEND OR ENABLE_MKLCPU_BACKEND OR ENABLE_CUFFT_BACKEND OR ENABLE_ROCFFT_BACKEND OR ENABLE_PORTFFT_BACKEND)
   list(APPEND DFT_RT_SOURCES "real_fwd_usm")
 endif()
 
 if(ENABLE_MKLGPU_BACKEND)
   list(APPEND DEVICE_FILTERS "level_zero:gpu")
 endif()
+if(ENABLE_MKLCPU_BACKEND)
+  list(APPEND DEVICE_FILTERS "opencl:cpu")
+endif()
 if(ENABLE_PORTFFT_BACKEND)
   list(APPEND DEVICE_FILTERS "*:gpu")
 endif()