So verwenden GCC 5.1 und OpenMP Arbeit Xeon Phi abzuladen

Question

Hintergrund

Wir haben erfolglos versucht, die neue GCC 5.1 Release zu verwenden OpenMP Blöcke auf die Intel MIC (das heißt der Xeon Phi) abzuladen. Nach der GCC Offloading Seite, haben wir das Skript build.sh zusammengestellt, um den "accel" Target Compiler für "intelmic" und den Host Compiler zu erstellen. Die Kompilierung scheint erfolgreich abgeschlossen zu sein.

Mit dem env.sh Skript versuchen wir dann, das einfache Programm hello.c zu kompilieren, das unten aufgeführt ist. Dieses Programm scheint jedoch nur auf dem Host und nicht auf dem Zielgerät ausgeführt zu werden.

Da wir im Allgemeinen neu sind und GCC kompilieren, gibt es mehrere Dinge, die wir falsch machen könnten. Allerdings haben wir die Ressourcen bereits erwähnten sowie die folgenden (ich habe nicht genug rep schreiben die Links) untersucht:

• Offloading für Xeon Phi
• Xeon Phi Tutorial
• Intel Xeon Phi Offload Programmierung Modelle

Das größte Problem ist, sie beziehen sich normalerweise auf den Intel-Compiler. Während wir planen, eine Kopie zu kaufen, haben wir derzeit keine Kopie. Darüber hinaus ist der Großteil unserer Entwicklungspipeline bereits in GCC integriert, und wir würden es (wenn möglich) auch so beibehalten.

Wir haben die neueste MPSS 3.5-Distribution installiert und die notwendigen Änderungen vorgenommen, um unter Ubuntu zu arbeiten. Wir können erfolgreich kommunizieren und den Status des Xeon Phis in unserem System überprüfen.

In unserem Bemühen haben wir nie gesehen, dass der Code auch im Mic-Emulationsmodus lief.

Fragen

1. Hat jemand erfolgreich eine Host/Ziel-GCC Compiler Kombination aufgebaut, die auf die Xeon Phi tatsächlich auslagert? Wenn ja, welche Ressourcen haben Sie verwendet?
2. Vermissen wir etwas im Build-Skript?
3. Ist mit dem Testquellcode etwas nicht in Ordnung? Sie kompilieren ohne Fehler (außer was unten erwähnt wird) und laufen mit 48 Threads (d. H. Der Anzahl der logischen Threads im Host-System).
4. Da Google-Suche nicht viel verraten, hat jemand Vorschläge für den nächsten Schritt (neben GCC Offloading aufgeben)? Ist das ein Fehler?

Danke!

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 

hallo.c (Version 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  
    } 
    }  
} 

Wir diesen Code kompiliert mit:

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

hello_omp.c (Version 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  
    } 
    }  
} 

Fast die gleiche Sache, aber stattdessen haben wir versucht, die

#pragma omp target device 

Syntax. In der Tat, mit mic, klagt es, aber mit irgendwelchen Gerätenummern (d. H. 0) kompiliert und läuft auf dem Host. Dieser Code wurde auf die gleiche Weise kompiliert.

Answer 1

Die Entladung auf Xeon Phi mit GCC 5 ist möglich. Um es zum Laufen zu bringen, muss man liboffloadmic für natives MIC-Ziel kompilieren, ähnlich wie es gemacht wird here. Das Problem bei der Einrichtung besteht darin, dass die Hostemulationsbibliotheken (libcoi_host.so, libcoi_device.so) kompiliert werden und Sticks mit emuliertem Entladen vorliegen, obwohl das physische Xeon Phi vorhanden ist.