Phenquestions
Oversikt
I denne guiden vil vi utforske kraften til GPU-programmering med C++. Utviklere kan forvente utrolig ytelse med C ++, og tilgang til den fenomenale kraften til GPU med et lavt nivå språk kan gi noen av de raskeste beregningene som er tilgjengelige for øyeblikket.
Krav
Mens enhver maskin som kan kjøre en moderne versjon av Linux, kan støtte en C ++ - kompilator, trenger du en NVIDIA-basert GPU for å følge med på denne øvelsen. Hvis du ikke har en GPU, kan du spinne opp en GPU-drevet forekomst i Amazon Web Services eller en annen skyleverandør du ønsker.
Hvis du velger en fysisk maskin, må du sørge for at NVIDIA-driverne er installert. Du finner instruksjoner for dette her: https: // linuxhint.no / install-nvidia-drivers-linux /
I tillegg til sjåføren trenger du CUDA-verktøysettet. I dette eksemplet bruker vi Ubuntu 16.04 LTS, men det er nedlastinger tilgjengelig for de fleste store distribusjoner på følgende URL: https: // utvikler.nvidia.com / cuda-nedlastinger
For Ubuntu ville du velge .deb-basert nedlasting. Den nedlastede filen har ikke en .deb-utvidelse som standard, så jeg anbefaler å gi den nytt navn for å ha en .deb på slutten. Deretter kan du installere med:
sudo dpkg -i pakkenavn.debDu vil sannsynligvis bli bedt om å installere en GPG-nøkkel, og hvis ja, følg instruksjonene for å gjøre det.
Når du har gjort det, oppdater repositoriene dine:
sudo apt-get oppdateringsudo apt-get install cuda -y
Når du er ferdig, anbefaler jeg omstart for å sikre at alt er riktig lastet.
Fordelene med GPU-utvikling
CPUer håndterer mange forskjellige innganger og utganger og inneholder et stort utvalg av funksjoner for ikke bare å håndtere et bredt utvalg av programbehov, men også for å administrere varierende maskinvarekonfigurasjoner. De håndterer også minne, caching, systembussen, segmentering og IO-funksjonalitet, noe som gjør dem til en jack of all trades.
GPUer er det motsatte - de inneholder mange individuelle prosessorer som er fokusert på veldig enkle matematiske funksjoner. På grunn av dette behandler de oppgaver mange ganger raskere enn CPUer. Ved å spesialisere seg i skalarfunksjoner (en funksjon som tar en eller flere innganger, men bare returnerer en enkelt utgang), oppnår de ekstrem ytelse på bekostning av ekstrem spesialisering.
Eksempel på kode
I eksempelkoden legger vi til vektorer sammen. Jeg har lagt til en CPU- og GPU-versjon av koden for hastighetssammenligning.
gpu-eksempel.cpp innholdet nedenfor:
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
typedef std :: chrono :: high_resolution_ Clock Clock;
#definer ITER 65535
// CPU-versjon av vector add-funksjonen
ugyldig vektor_add_cpu (int * a, int * b, int * c, int n)
int i;
// Legg vektorelementene a og b til vektoren c
for (i = 0; i < n; ++i)
c [i] = a [i] + b [i];
// GPU-versjon av vector add-funksjonen
__global__ ugyldig vektor_add_gpu (int * gpu_a, int * gpu_b, int * gpu_c, int n)
int i = threadIdx.x;
// Ingen for loop nødvendig fordi CUDA-kjøretiden
// vil tråde dette ITER ganger
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 * sizeof (int));
b = (int *) malloc (ITER * sizeof (int));
c = (int *) malloc (ITER * sizeof (int));
// Vi trenger variabler tilgjengelig for GPU,
// så cudaMallocManaged gir disse
cudaMallocManaged (& gpu_a, ITER * sizeof (int));
cudaMallocManaged (& gpu_b, ITER * sizeof (int));
cudaMallocManaged (& gpu_c, ITER * sizeof (int));
for (int i = 0; i < ITER; ++i)
a [i] = i;
b [i] = i;
c [i] = i;
// Ring CPU-funksjonen og tidsbestem den
auto cpu_start = Klokke :: nå ();
vector_add_cpu (a, b, c, ITER);
auto cpu_end = Klokke :: nå ();
std :: cout << "vector_add_cpu: "
<< std::chrono::duration_cast
<< " nanoseconds.\n";
// Ring GPU-funksjonen og tidsbestem den
// Trippelvinkelbremsene er en CUDA kjøretidsforlengelse som tillater det
// parametere for et CUDA-kjerneanrop som skal sendes.
// I dette eksemplet passerer vi en trådblokk med ITER-tråder.
auto gpu_start = Klokke :: nå ();
vector_add_gpu <<<1, ITER>>> (gpu_a, gpu_b, gpu_c, ITER);
cudaDeviceSynchronize ();
auto gpu_end = Klokke :: nå ();
std :: cout << "vector_add_gpu: "
<< std::chrono::duration_cast
<< " nanoseconds.\n";
// Frigjør GPU-funksjonsbaserte minnetildelinger
cudaFree (a);
cudaFree (b);
cudaFree (c);
// Frigjør CPU-funksjonsbaserte minnetildelinger
gratis (a);
gratis (b);
gratis (c);
retur 0;
Makefile innholdet nedenfor:
INC = -I / usr / local / cuda / includeNVCC = / usr / local / cuda / bin / nvcc
NVCC_OPT = -std = c ++ 11
alle:
$ (NVCC) $ (NVCC_OPT) gpu-eksempel.cpp -o gpu-eksempel
ren:
-rm -f gpu-eksempel
For å kjøre eksemplet, kompiler det:
gjøreKjør deretter programmet:
./ gpu-eksempelSom du kan se, kjører CPU-versjonen (vector_add_cpu) betydelig tregere enn GPU-versjonen (vector_add_gpu).
Hvis ikke, må du kanskje justere ITER-definisjonen i gpu-eksempel.cu til et høyere tall. Dette skyldes at GPU-installasjonstiden er lengre enn noen mindre CPU-intensive sløyfer. Jeg fant 65535 som fungerer bra på maskinen min, men kjørelengden din kan variere. Når du har fjernet denne terskelen, er GPUen imidlertid dramatisk raskere enn CPU.
Konklusjon
Jeg håper du har lært mye av introduksjonen til GPU-programmering med C++. Eksemplet ovenfor oppnår ikke mye, men konseptene som vises, gir et rammeverk som du kan bruke til å innlemme ideene dine for å frigjøre kraften til GPUen din.
