Set Up for CPU Offload

Make sure you have followed all steps in the oneAPI Development Environment Setup section, including running the
setvars
script.
Check if you have the required OpenCL runtime associated with the CPU using the
sycl-ls
command. For example:
$sycl-ls
CPU : OpenCL 2.1 (Build 0)[ 2020.11.12.0.14_160000 ]
GPU : OpenCL 3.0 NEO [ 21.33.20678 ]
GPU : 1.1[ 1.2.20939 ]
Use one of the following code samples to verify that your code is running on the CPU. The code sample adds scalar to large vectors of integers and verifies the results.

export SYCL_DEVICE_FILTER=cpu

#include <CL/sycl.hpp>
#include <array>
#include <iostream>


using namespace sycl;
using namespace std;
constexpr size_t array_size = 10000;
int main(){
constexpr int value = 100000;
try{
        cpu_selector d_selector;
        queue q(d_selector);
        int *sequential = malloc_shared<int>(array_size, q);
        int *parallel = malloc_shared<int>(array_size, q);
        //Sequential iota
        for (size_t i = 0; i < array_size; i++) sequential[i] = value + i;


        //Parallel iota in SYCL
        auto e = q.parallel_for(range{array_size}, [=](auto i) { parallel[i] = value + i; });
        e.wait();
   // Verify two results are equal.
    for (size_t i = 0; i < array_size; i++) {
      if (parallel[i] != sequential[i]) {
        cout << "Failed on device.\n";
        return -1;
      }
    }
    free(sequential, q);
    free(parallel, q);
}catch (std::exception const &e) {
    cout << "An exception is caught while computing on device.\n";
    terminate();
}
 cout << "Successfully completed on device.\n";
  return 0;
}

dpcpp simple-iota-dp.cpp -o simple-iota.

./simple-iota
Running on device: Intel® Core™ i7-8700 CPU @ 3.20GHz
Successfully completed on device.

#include<iostream>
#include<omp.h>
#define N 1024
int main(){
float *a = (float *)malloc(sizeof(float)*N);
for(int i = 0; i < N; i++)
a[i] = i;
#pragma omp target teams distribute parallel for simd map(tofrom: a[:N])
for(int i = 0; i < 1024; i++)
a[i]++;
std::cout<<a[100]<<"\n";
return 0;
}

export LIBOMPTARGET_DEVICETYPE=cpu

icpx simple-ompoffload.cpp -fiopenmp -fopenmp-targets=spir64 -o simple-ompoffload

./simple-ompoffload
Successfully completed on device

Offload Code to CPU

Debug Offloaded Code

Check host target to verify the correctness of your code.
Use
printf
to debug your application. Both SYCL and OpenMP offload support
printf
in kernel code.
Use environment variables to control verbose log information.
For SYCL, the following debug environment variables are recommended. A full list of environment variables is available from GitHub.

SYCL Recommended Debug Environment Variables

Name	Value	Description
SYCL_DEVICE_FILTER	backend:device_type:device_num	GitHub description
SYCL_PI_TRACE	1|2|-1	1: print out the basic trace log of the SYCL/DPC++ runtime plugin 2: print out all API traces of SYCL/DPC++ runtime plugin -1: all of “2” including more debug messages

For OpenMP, the following debug environment variables are recommended. A full list is available from the LLVM/OpenMP documentation.

OpenMP Recommended Debug Environment Variables

Name	Value	Description
LIBOMPTARGET_DEVICETYPE	cpu|gpu|host	Select
LIBOMPTARGET_DEBUG	1	Print out verbose debug information
LIBOMPTARGET_INFO	Values available in LLVM/OpenMP documentation	Allows the user to request different types of runtime information from libomptarget
Use Ahead of Time (AOT) to move Just-in-Time (JIT) compilations to AOT compilation issues. For more information, see Ahead-of-Time Compilation for CPU Architectures.

Optimize CPU Code

If the amount of work being done by the core is not compute-intensive, then this could hurt performance. This is because of the scheduling overhead and thread context switching.
On a CPU, there is no need for data transfer through PCIe, resulting in lower latency because the offload region does not have to wait long for the data.
Based on the nature of your application, thread affinity could affect the performance on CPU. For details, see Control Binary Execution on Multiple Cores.
Offloaded code uses JIT compilation by default. Use AOT compilation (offline compilation) instead. With offline compilation, you could target your code to specific CPU architecture. Refer to Optimization Flags for CPU Architectures for details.