Phenquestions
Áttekintés
Ebben az útmutatóban megvizsgáljuk a GPU programozásának erejét a C-vel++. A fejlesztők hihetetlen teljesítményre számíthatnak a C ++ használatával, és a GPU fenomenális erejének elérése alacsony szintű nyelvvel a jelenleg elérhető leggyorsabb számításokat eredményezheti.
Követelmények
Bár minden olyan gép, amely képes a Linux modern verziójának futtatására, képes támogatni a C ++ fordítóprogramot, ehhez a gyakorlathoz egy NVIDIA alapú GPU-ra van szükség. Ha még nem rendelkezik GPU-val, akkor egy GPU-alapú példányt felpörgethet az Amazon Web Services szolgáltatásban vagy egy másik választott felhőszolgáltatóban.
Ha fizikai gépet választ, győződjön meg arról, hogy telepítette az NVIDIA saját illesztőprogramjait. Ehhez itt talál útmutatást: https: // linuxhint.com / install-nvidia-drivers-linux /
Az illesztőprogram mellett szüksége lesz a CUDA eszköztárra. Ebben a példában az Ubuntu 16-at fogjuk használni.04 LTS, de a legtöbb nagy disztribúcióhoz elérhető letöltések elérhetők a következő URL-címen: https: // developer.nvidia.com / cuda-downloads
Az Ubuntu esetében a .deb alapú letöltés. A letöltött fájl nem rendelkezik a .alapértelmezés szerint a deb kiterjesztés, ezért azt ajánlom átnevezni, hogy a .deb a végén. Ezután telepítheti:
sudo dpkg -i csomagnév.debValószínűleg a rendszer felkéri, hogy telepítse a GPG kulcsot, és ha igen, kövesse a megadott utasításokat.
Miután ezt megtette, frissítse az adattárakat:
sudo apt-get frissítéssudo apt-get install cuda -y
Miután elkészült, javasoljuk az újraindítást, hogy minden megfelelően be legyen töltve.
A GPU fejlesztésének előnyei
A CPU-k sokféle bemenetet és kimenetet kezelnek, és sokféle funkciót tartalmaznak, nemcsak a programigények széles választékának kezelésére, hanem a különböző hardverkonfigurációk kezelésére is. Emellett kezelik a memóriát, a gyorsítótárat, a rendszerbuszt, a szegmentálást és az IO funkciókat, így minden kereskedelem jack.
A GPU-k ezzel ellentétesek - sok egyedi processzort tartalmaznak, amelyek nagyon egyszerű matematikai funkciókra összpontosítanak. Emiatt sokszor gyorsabban dolgoznak fel feladatokat, mint a CPU-k. A skaláris függvényekre szakosodva (olyan funkció, amely egy vagy több bemenetet vesz fel, de csak egyetlen kimenetet ad vissza) rendkívüli teljesítményt érnek el extrém specializáció árán.
Példakód
A példakódban vektorokat adunk össze. A sebesség összehasonlításához hozzáadtam a kód CPU és GPU változatát.
gpu-példa.cpp az alábbi tartalom:
#include
#include
#include
#include
#include
typedef std :: chrono :: high_resolution_clock Óra;
#define ITER 65535
// A vektor hozzáadási függvény CPU-verziója
void vector_add_cpu (int * a, int * b, int * c, int n)
int i;
// Adjuk hozzá az a és b vektor elemeket a c vektorhoz
mert (i = 0; i < n; ++i)
c [i] = a [i] + b [i];
// A vektor hozzáadási függvény GPU verziója
__global__ void vector_add_gpu (int * gpu_a, int * gpu_b, int * gpu_c, int n)
int i = threadIdx.x;
// Nem szükséges a hurokhoz, mert a CUDA futásideje
// ezt az ITER-szálat szálra fűzi
gpu_c [i] = gpu_a [i] + gpu_b [i];
int main ()
int * a, * b, * c;
int * gpu_a, * gpu_b, * gpu_c;
a = (int *) malloc (ITER * (int) mérete);
b = (int *) malloc (ITER * (int) mérete);
c = (int *) malloc (ITER * (int) mérete);
// Szükségünk van a GPU által elérhető változókra,
// így a cudaMallocManaged biztosítja ezeket
cudaMallocManaged (& gpu_a, ITER * sizeof (int));
cudaMallocManaged (& gpu_b, ITER * sizeof (int));
cudaMallocManaged (& gpu_c, ITER * sizeof (int));
mert (int i = 0; i < ITER; ++i)
a [i] = i;
b [i] = i;
c [i] = i;
// Hívja meg a CPU függvényt és időzítse
auto cpu_start = Óra :: most ();
vector_add_cpu (a, b, c, ITER);
auto cpu_end = Óra :: most ();
std :: cout << "vector_add_cpu: "
<< std::chrono::duration_cast
<< " nanoseconds.\n";
// Hívja meg a GPU függvényt és időzítse
// A hármas szögű fékek egy CUDA futásidejű kiterjesztés, amely lehetővé teszi
// átadandó CUDA-kernelhívás paraméterei.
// Ebben a példában egy szálblokkot adunk át ITER szálakkal.
auto gpu_start = Óra :: most ();
vector_add_gpu <<<1, ITER>>> (gpu_a, gpu_b, gpu_c, ITER);
cudaDeviceSynchronize ();
auto gpu_end = Óra :: most ();
std :: cout << "vector_add_gpu: "
<< std::chrono::duration_cast
<< " nanoseconds.\n";
// Szabadítsa fel a GPU-függvény alapú memóriafoglalásokat
cudaFree (a);
cudaFree (b);
cudaFree (c);
// Szabadítsa fel a CPU-függvény alapú memóriafoglalásokat
szabad (a);
szabad (b);
szabad (c);
visszatér 0;
Makefile az alábbi tartalom:
INC = -I / usr / local / cuda / includeNVCC = / usr / local / cuda / bin / nvcc
NVCC_OPT = -std = c ++ 11
minden:
$ (NVCC) $ (NVCC_OPT) gpu-példa.cpp -o gpu-example
tiszta:
-rm -f gpu-example
A példa futtatásához fordítsa le:
készítsenEzután futtassa a programot:
./ gpu-exampleMint látható, a CPU verzió (vector_add_cpu) lényegesen lassabban fut, mint a GPU verzió (vector_add_gpu).
Ha nem, akkor lehet, hogy módosítania kell az ITER definíciót a gpu-example példában.cu nagyobb számra. Ennek oka, hogy a GPU telepítési ideje hosszabb, mint néhány kisebb CPU-intenzív huroké. Úgy találtam, hogy 65535 jól működik a gépemen, de a futásteljesítmény változhat. Miután azonban törölte ezt a küszöböt, a GPU drámaian gyorsabb, mint a CPU.
Következtetés
Remélem, sokat tanultál a C-vel történő GPU-programozás bevezetéséből++. A fenti példa nem sokat ér el, de a bemutatott koncepciók olyan keretet nyújtanak, amelyet felhasználhat ötleteinek beépítéséhez, hogy felszabadítsa a GPU erejét.
