Hey there, let's break down your problem clearly:

First, the short answer: Clang 3.9.0 has limited, experimental support for OpenMP GPU offload, and it only works with NVIDIA CUDA GPUs. The warning you're seeing is because x86_64-unknown-linux-gnu is your host CPU architecture, not a GPU target—so the compiler just ignores that unused flag.

Here's what you need to do to get your matrix multiplication running on GPU:

1. Prerequisites for GPU Offload with Clang 3.9 #

• You must have the CUDA SDK installed (CUDA 8.0 is the most compatible version for Clang 3.9). Clang 3.9 relies on the CUDA toolchain to generate GPU-ready PTX code.
• Your cluster's GPU has to be NVIDIA-based—Clang 3.9 doesn't support AMD or other GPU architectures for OpenMP offload.

2. Fixing the Compilation Command #

Clang 3.9 didn't fully flesh out the -fopenmp-targets flag for GPUs yet. Instead, you need to use CUDA-specific flags to trigger offload:

clang -O3 -fopenmp --cuda-gpu-arch=sm_XX mm.c -o mm

• Replace sm_XX with your GPU's compute capability (e.g., sm_35 for older Kepler cards, sm_52 for Maxwell, sm_60 for Pascal). You can find this by checking your GPU model with nvidia-smi and looking up its compute capability.
• The -fopenmp flag enables OpenMP support and tells Clang to use its CUDA backend to compile the target region for GPU.

If your CUDA SDK isn't in the default system path, add these flags to point to it:

clang -O3 -fopenmp --cuda-gpu-arch=sm_XX -I/usr/local/cuda/include -L/usr/local/cuda/lib64 -lcudart mm.c -o mm

3. Tweaking Your Code for Reliable Offload #

Your current code uses shared(C,P,T) which can cause issues with GPU memory mapping—host and GPU memory are separate, so explicit mapping is safer. Update your OpenMP directive like this:

#pragma omp target parallel for map(to:P,T) map(from:C) private(i,j,k)
for (i=0; i<N; i++) {
    for (j=0; j<N; j++) {
        for (k=0; k<N; k++) {
            C[i][j] += P[i][k]*T[k][j];
        }
    }
}

• map(to:P,T) sends your input matrices to the GPU.
• map(from:C) brings the computed result back to the host.
• Explicit mapping avoids unexpected behavior from the default shared rule, which doesn't account for the GPU's separate memory space.

4. Limitations & Workarounds #

Clang 3.9's OpenMP offload is experimental, so you might hit bugs or unsupported features. If you run into trouble:

• Upgrade Clang if possible: Versions 10 and later have much better support for OpenMP GPU offload, and you can use the more intuitive -fopenmp-targets=nvptx64-nvidia-cuda flag.
• Alternative approaches: If you can't upgrade, consider writing the matrix multiplication directly in CUDA C, or using OpenACC if your cluster supports it.

内容的提问来源于stack exchange，提问作者armando