Come usare GCC 5.1 e OpenMP per scaricare il lavoro di Xeon Phi

Question

Sfondo

Abbiamo cercato, senza successo, di utilizzare il nuovo GCC 5.1 rilascio di scaricare blocchi OpenMP per Intel MIC (vale a dire la Xeon Phi). Seguendo la pagina GCC Offloading, abbiamo creato lo script build.sh per compilare il compilatore di destinazione "accel" per "intelmic" e il compilatore host. La compilazione sembra completata con successo.

Utilizzando lo script env.sh, tentiamo quindi di compilare il semplice programma hello.c elencato di seguito. Tuttavia, questo programma sembra funzionare solo sull'host e non sul dispositivo di destinazione.

Dato che siamo nuovi nell'offloading in generale, oltre a compilare GCC, ci sono molte cose che potremmo fare in modo errato. Tuttavia, abbiamo studiato le risorse già citate più le seguenti (non ho abbastanza rep di inviare i link):

• Offloading per Xeon Phi
• Xeon Phi Tutorial
• Intel Xeon Phi Offload Programmazione Modelli

Il problema più grande è che di solito fanno riferimento al compilatore Intel. Mentre pianifichiamo l'acquisto di una copia, al momento NON ne abbiamo una copia. Inoltre, la maggior parte della nostra pipeline di sviluppo è già integrata con GCC e preferiremmo mantenerla in questo modo (se possibile).

Abbiamo installato l'ultima distribuzione di MPSS 3.5, apportando le modifiche necessarie per lavorare con Ubuntu. Possiamo comunicare e verificare correttamente lo stato di Xeon Phis nel nostro sistema.

Nei nostri sforzi, non abbiamo mai visto alcuna indicazione che il codice fosse in esecuzione nella modalità di emulazione del microfono.

Domande

1. Qualcuno ha costruito con successo una combinazione compilatore host/destinazione GCC che scarica in realtà al Xeon Phi? Se sì, quali risorse hai usato?
2. Ci manca qualcosa nello script di compilazione?
3. C'è qualcosa che non va nel codice sorgente del test? Si compilano senza errori (eccetto ciò che è menzionato sotto) e funzionano con 48 thread (cioè il numero di thread logici nel sistema host).
4. Poiché la ricerca di Google non rivela molto, qualcuno ha suggerimenti per il prossimo passo (oltre a rinunciare allo scaricamento GCC)? è un insetto?

Grazie!

build.sh

#!/usr/bin/env bash                                   

set -e -x 
unset LIBRARY_PATH 

GCC_DIST=$PWD/gcc-5.1.0 

# Modify these to control where the compilers are installed                         
TARGET_PREFIX=$HOME/gcc 
HOST_PREFIX=$HOME/gcc 

TARGET_BUILD=/tmp/gcc-build-mic 
HOST_BUILD=/tmp/gcc-build-host 

# i dropped the emul since we are not planning to emulate!                          
TARGET=x86_64-intelmic-linux-gnu 
# should this be a quad (i.e. pc)?? default (Ubuntu) build seems to be x86_64-linux-gnu                  
HOST=x86_64-pc-linux-gnu 

# check for the GCC distribution                                
if [ ! -d $GCC_DIST ]; then 
    echo "gcc-5.1.0 distribution should be here $PWD" 
    exit 0 
fi 

#sudo apt-get install -y libmpfr-dev libgmp-dev libmpc-dev libisl-dev dejagnu autogen sysvbanner                

# prepare and configure the target compiler                             
mkdir -p $TARGET_BUILD 
pushd $TARGET_BUILD 
$GCC_DIST/configure \ 
    --prefix=$TARGET_PREFIX \ 
    --enable-languages=c,c++,fortran,lto \ 
    --enable-liboffloadmic=target \ 
    --disable-multilib \ 
    --build=$TARGET \ 
    --host=$TARGET \ 
    --target=$TARGET \ 
    --enable-as-accelerator-for=$HOST \ 
    --program-prefix="${TARGET}-" 
    #--program-prefix="$HOST-accel-$TARGET-" \                             
# try adding the program prefix as HINTED in the https://gcc.gnu.org/wiki/Offloading                   
# do we need to specify a sysroot??? Wiki says we don't need one... but it also says "better to configure as cross compiler....        

# build and install                                   
make -j48 && make install 
popd 

# prepare and build the host compiler                               
mkdir -p $HOST_BUILD 
pushd $HOST_BUILD 
$GCC_DIST/configure \ 
    --prefix=$HOST_PREFIX \ 
    --enable-languages=c,c++,fortran,lto \ 
    --enable-liboffloadmic=host \ 
    --disable-multilib \ 
    --build=$HOST \ 
    --host=$HOST \ 
    --target=$HOST \ 
    --enable-offload-targets=$TARGET=$TARGET_PREFIX 

make -j48 && make install 
popd 

env.sh

#!/usr/bin/env bash 

TARGET_PREFIX=$HOME/gcc 
HOST_PREFIX=$HOME/gcc 
HOST=x86_64-pc-linux-gnu 
VERSION=5.1.0 

export LD_LIBRARY_PATH=/opt/intel/mic/coi/host-linux-release/lib:/opt/mpss/3.4.3/sysroots/k1om-mpss-linux/usr/lib64:$LD_LIBRARY_PATH 
export LD_LIBRARY_PATH=$HOST_PREFIX/lib:$HOST_PREFIX/lib64:$HOST_PREFIX/lib/gcc/$HOST/$VERSION:$LD_LIBRARY_PATH 
export PATH=$HOST_PREFIX/bin:$PATH 

ciao.c (versione 1)

#include <omp.h> 
#include <stdio.h> 
#include <stdlib.h> 

int main (int argc, char *argv[]) 
{ 
    int nthreads, tid; 
    /* Fork a team of threads giving them their own copies of variables */ 

#pragma offload target (mic) 
    { 
#pragma omp parallel private(nthreads,tid) 
    { 
     /* Obtain thread number */ 
     tid = omp_get_thread_num(); 
     printf("Hello World from thread = %d\n", tid); 

     /* Only master thread does this */ 
     if (tid == 0) { 
     nthreads = omp_get_num_threads(); 
     printf("Number of threads = %d\n", nthreads); 
     }  
#ifdef __MIC__ 
     printf("on target...\n"); 
#else 
     printf("on host...\n"); 
#endif  
    } 
    }  
} 

Abbiamo compilato questo codice con:

gcc -fopenmp -foffload=x86_64-intelmic-linux-gnu hello.c -o hello 

hello_omp.c (versione 2)

#include <omp.h> 
#include <stdio.h> 
#include <stdlib.h> 

int main (int argc, char *argv[]) 
{ 
    int nthreads, tid; 
    /* Fork a team of threads giving them their own copies of variables */ 

#pragma omp target device(mic) 
    { 
#pragma omp parallel private(nthreads,tid) 
    { 
     /* Obtain thread number */ 
     tid = omp_get_thread_num(); 
     printf("Hello World from thread = %d\n", tid); 

     /* Only master thread does this */ 
     if (tid == 0) { 
    nthreads = omp_get_num_threads(); 
    printf("Number of threads = %d\n", nthreads); 
     }  
#ifdef __MIC__ 
     printf("on target...\n"); 
#else 
     printf("on host...\n"); 
#endif  
    } 
    }  
} 

quasi la stessa cosa, ma invece abbiamo provato la

#pragma omp target device 

sintassi. In effetti, con mic, si lamenta, ma con qualsiasi numero di dispositivo (ad esempio 0) viene compilato e eseguito sull'host. Questo codice è stato compilato nello stesso modo.

Answer 1

È possibile lo scaricamento su Xeon Phi con GCC 5. Per farlo funzionare, è necessario compilare liboffloadmic per il target MIC nativo, analogamente a come è fatto here. Il problema dell'impostazione è che compila le librerie di emulazione host (libcoi_host.so, libcoi_device.so) e si attacca allo scaricamento emulato anche se è presente Xeon Phi fisico.