CUDA
CUDA представляет из себя модификацию языка C, поэтому для исходных файлов принято использовать специальное расширение — ‘cu‘ вместо ‘c’.
host — компьютер ‘в обычном понимании’, управляемый CPU.
device (устройство) — карта с GPU.
kernel (ядро) — функция, которая будет запущена в нескольких экземплярах, каждый из которых будет работать на своём ядре устройства. Для указания, что функция будет ядром, при её описании используется спецификатор
___global___
Выполнение ядра с распараллеливанием на N потоков описывается следующим образом:
MyKernel>>(параметры);
Используемое ПО
CUDA Toolkit
CUDA Toolkit предоставляет полную среду разработки на C и C++ с использованием вычислений на GPU NVIDIA. Включает компилятор для GPU, инструменты для отладки и оптимизации, математические библиотеки и документацию.
Разные версии CUDA Toolkit установлены в поддиректории внутри директории ‘/opt/shared/nvidia’. Например, версия 8.0 установлена в ‘/opt/shared/nvidia/cuda-8.0’. При этом символьная ссылка ‘/opt/shared/nvidia/cuda‘ указывает на директорию с последней установленной версией.
Для использования необходимо настроить переменные окружения следующим образом:
export PATH=$PATH:/opt/shared/nvidia/cuda/bin export LD_LIBRARY_PATH=/opt/shared/nvidia/cuda/lib64:$LD_LIBRARY_PATH
Тоже самое можно сделать с помощью утилиты module:
module load nvidia/cuda-toolkit
Если необходимо использовать какую-то другую установленную версию, пути (или параметр для ‘module’) необходимо поменять соответствующим образом.
Если необходимо использовать версию, не установленную у нас, вы можете самостоятельно установить её в свою домашнюю директорию. Это не требует повышенных прав.
CUDA Code Samples
CUDA Code Samples (предыдущее название — GPU Computing SDK) содержит примеры кода и официальные документы, призванные помочь создавать ПО, использующее NVIDIA GPU, с помощью CUDA C/C++, OpenCL или DirectCompute.
Установлено в директории вида /opt/shared/nvidia/NVIDIA_CUDA-6.0_Samples (в зависимости от версии).
Пример
Ниже приведён пример запуска программы, складывающей средствами CUDA два вектора ‘A’ и ‘B’ (т.е. два массива поэлементно) и сохраняющей сумму в вектор ‘С’.
Поскольку GPU обрабатывает данные, находящиеся в своей собственной памяти, а не в ОЗУ компьютера, требуются дополнительные действия — выделение памяти на устройстве, копирование туда исходных данных, копирование полученного результата обратно на компьютер.
Номер устройства, которое будет использоваться, программа будет получать при запуске в качестве первого параметра.
Создать файл ‘addvectors.cu‘ следующего содержания:
#include #include "cuda.h" #define N 128 int assigned_device; int used_device; // Data on the host system int HostA[N]; int HostB[N]; int HostC[N]; // Pointers to data on the device int *DeviceA; int *DeviceB; int *DeviceC; //---------------------------------------------------------- __global__ void AddVectors(int* a, int* b, int* c) < int i = threadIdx.x; c[i] = a[i] + b[i]; >//---------------------------------------------------------- int main(int argc, char** argv) < // Define the device to use: if (argc < 2) < printf ("Error: device number is absent\n"); return 100; >assigned_device=atoi(argv[1]); if ( strlen(argv[1]) > 1 or ( assigned_device == 0 and strcmp(argv[1],"0") != 0 ) ) < printf ("Error: device number is incorrect\n"); return 110; >// Select the used device: if ( cudaSetDevice(assigned_device) != cudaSuccess or cudaGetDevice( &used_device ) != cudaSuccess or used_device != assigned_device ) < printf ("Error: unable to set device %d\n", assigned_device); return 120; >printf ("Used device: %d\n", used_device); // Initialize summands: for (int i=0; i // Allocate memory on the device: cudaMalloc((void**)&DeviceA, N*sizeof(int)); cudaMalloc((void**)&DeviceB, N*sizeof(int)); cudaMalloc((void**)&DeviceC, N*sizeof(int)); // Copy summands from host to device: cudaMemcpy(DeviceA, HostA, N*sizeof(int), cudaMemcpyHostToDevice); cudaMemcpy(DeviceB, HostB, N*sizeof(int), cudaMemcpyHostToDevice); // Execute kernel: AddVectors>>(DeviceA, DeviceB, DeviceC); // Copy result from device to host: cudaMemcpy(HostC, DeviceC, N*sizeof(int), cudaMemcpyDeviceToHost); // Show result: for (int i=0; i cudaFree(DeviceA); cudaFree(DeviceB); cudaFree(DeviceC); >
Для установки переменных окружения выполнить:
module load nvidia/cuda-toolkit
Для компилирования используется утилита nvcc. Необходимо выполнить:
nvcc -arch=compute_20 addvectors.cu -o addvectors
Либо можно использовать ‘makefile’ следующего содержания
addvectors : addvectors.cu nvcc -arch=compute_20 addvectors.cu -o $@
В результате должен быть создан исполняемый файл ‘addvectors’
Для взаимодействия с планировщиком PBS создать файл ‘submit.sh‘ следующего содержания:
#!/bin/sh #PBS -q teslaq #PBS -l walltime=0:01:00 #PBS -l select=1:ngpus=1:ncpus=4:mem=32gb cd $PBS_O_WORKDIR vnodes=$(qstat -f $PBS_JOBID|grep exec_vnode|sed -e 's/ *//') if [ $( echo $vnodes|grep -c '+') != 0 ] ; then echo "Error: several vnodes are provided." exit 100 fi gpu_nbr=$(echo $vnodes|sed 's/.*\[//'|sed 's/\].*//') echo "GPU number from vnodes = $gpu_nbr" echo export PATH=$PATH:/opt/shared/nvidia/cuda/bin export LD_LIBRARY_PATH=/opt/shared/nvidia/cuda/lib64:$LD_LIBRARY_PATH ./addvectors $gpu_nbr
Поставить задачу в очередь:
qsub submit.sh
После завершения в файле стандартного вывода будет получено примерно следующее:
GPU number from vnodes = 0 Used device: 0 0 + 0 = 0 2 + 3 = 5 4 + 6 = 10 6 + 9 = 15 8 + 12 = 20 . 246 + 369 = 615 248 + 372 = 620 250 + 375 = 625 252 + 378 = 630 254 + 381 = 635
MPI + CUDA
Для использования CUDA совместно с MPI необходимо использовать два компилятора — nvcc для кода CUDA и mpicc (mpiCC/mpicxx/…) для остального. Поэтому исходный текст должен быть разбит на несколько файлов таким образом, чтобы разделить CUDA и MPI код. Каждый файл компилируется соответствующим компилятором, но не до исполняемого файла, а до объектного. Затем все полученные объектные файлы объединяются в один исполняемый.
Кроме того, каждый процесс MPI должен знать, с каким именно GPU, присутствующем на сервере, он должен работать. Данная информация не предоставляется явно средствами PBS, MPI или CUDA и программа должна выяснять её самостоятельно.
Команда mpirun должна получить корректное значение переменной окружения LD_LIBRARY_PATH. Это необходимо, чтобы обеспечить установку этой переменной на всех используемых узлах. Без этого программа не найдёт библиотеки CUDA и завершится аварийно. При использовании OpenMPI это делается при помощи параметра ‘-x‘, для Intel MPI — параметром ‘-genvlist‘.
Ниже приведён рабочий пример, в котором каждый MPI-процесс работает со своим GPU.
Выбрать необходимую реализацию MPI:
mpi-selector --set openmpi_gcc-1.4.4
Переподключить SSH-соединение.
Установить переменные окружения для работы компилятора nvcc:
module load nvidia/cuda-toolkit
Создать файл ‘cuda_part.cu‘ следующего содержания:
#include #include "cuda.h" #define N 4 int used_device; // Data on the host system int HostA[N]; int HostB[N]; int HostC[N]; // Pointers to data on the device int *DeviceA; int *DeviceB; int *DeviceC; //---------------------------------------------------------- __global__ void AddVectors(int* a, int* b, int* c) < int i = threadIdx.x; c[i] = a[i] + b[i]; >//---------------------------------------------------------- extern "C" void exec_cuda(int mpi_rank, int assigned_device) < // Select the used device: if ( cudaSetDevice(assigned_device) != cudaSuccess or cudaGetDevice( &used_device ) != cudaSuccess or used_device != assigned_device ) < printf ("Error: unable to set device %d\n", assigned_device); return; >// Initialize summands: for (int i=0; i // Allocate memory on the device: cudaMalloc((void**)&DeviceA, N*sizeof(int)); cudaMalloc((void**)&DeviceB, N*sizeof(int)); cudaMalloc((void**)&DeviceC, N*sizeof(int)); // Copy summands from host to device: cudaMemcpy(DeviceA, HostA, N*sizeof(int), cudaMemcpyHostToDevice); cudaMemcpy(DeviceB, HostB, N*sizeof(int), cudaMemcpyHostToDevice); // Execute kernel: AddVectors>>(DeviceA, DeviceB, DeviceC); // Copy result from device to host: cudaMemcpy(HostC, DeviceC, N*sizeof(int), cudaMemcpyDeviceToHost); // Show result: for (int i=0; i cudaFree(DeviceA); cudaFree(DeviceB); cudaFree(DeviceC); >
Основное отличие от примера, приведённого выше для CUDA (без MPI) — вместо стандартной функции ‘main’ используется функция с другим именем и параметрами, описанная как ‘extern’.
Создать файл ‘mpi_part.c‘:
#include #include #include #include extern void exec_cuda(int, int); int *gpu_by_rank; int *vnode_is_used; //------------------------------------------------------------ int define_gpu (int rank, char *host, int argc, char** argv) < int i, gpu = -1; // 'argv' looks like the following: // ./mpi_cuda sl002 0 sl002 1 sl002 2 sl003 0 sl003 1 sl003 2 for (i=1; ireturn gpu; > //------------------------------------------------------------ int main(int argc, char** argv) < int size, rank, i, k, gpu; char host[32]; MPI_Status status; MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&size); MPI_Comm_rank(MPI_COMM_WORLD,&rank); // Validate arguments: if ( size != (argc-1)/2 ) < MPI_Finalize(); printf ("Error: amount of GPUs do not match the MPI size!\n"); return 100; >// Define correspondence between ranks and vnodes gpu: if ( rank == 0 ) < gpu_by_rank = (int *)malloc(size*sizeof(int)); vnode_is_used = (int *)malloc(size*sizeof(int)); for ( i=0; ifor ( i=1; i gethostname(host,32); gpu=define_gpu(0,host, argc, argv); free(gpu_by_rank); free(vnode_is_used); > else < gethostname(host,32); MPI_Send(host,32,MPI_CHAR,0,0,MPI_COMM_WORLD); MPI_Recv(&gpu,1,MPI_INT,0,0,MPI_COMM_WORLD, &status); >printf("I'm number %d from %d and I run on host %s, gpu %d.\n",rank,size,host,gpu); exec_cuda(rank,gpu); MPI_Finalize(); return 0; >
Скомпилировать до объектных файлов (*.o):
nvcc -arch=compute_20 -c cuda_part.cu mpicc -c mpi_part.c
и затем собрать в исполняемый ‘mpi_cuda‘:
mpicc mpi_part.o cuda_part.o -lm -lcudart -L/opt/shared/nvidia/cuda/lib64 -I/opt/shared/nvidia/cuda/include -o mpi_cuda
Либо можно использовать ‘makefile‘ следующего содержания:
mpi_cuda : mpi_part.o cuda_part.o mpicc mpi_part.o cuda_part.o -lm -lcudart -L/opt/shared/nvidia/cuda/lib64 -I/opt/shared/nvidia/cuda/include -o mpi_cuda cuda_part.o : cuda_part.cu nvcc -arch=compute_20 -c cuda_part.cu mpi_part.o : mpi_part.c mpicc -c mpi_part.c
Создать файл ‘submit.sh‘:
#!/bin/sh #PBS -q teslaq #PBS -l walltime=0:01:00 #PBS -l select=2:ngpus=3:ncpus=3:mpiprocs=3:mem=32gb,place=scatter cd $PBS_O_WORKDIR MPI_NP=$(wc -l $PBS_NODEFILE | awk '< print $1 >') vnodes=$(qstat -f $PBS_JOBID|tr -d '\n'' ''\t'|sed 's/Hold_Types.*//'|sed 's/.*exec_vnode=//'|tr -d \(\)|tr + '\n'|sed 's/:.*//'|sort) echo "My vnodes:" for vnode in $vnodes ; do node=$(echo $vnode|sed 's/\[.*//') gpu=$(echo $vnode|sed 's/.*\[//'|sed 's/\]//') echo " $vnode = Node $node, GPU $gpu" done echo ## Replace all '[' and ']' by spaces before passing to program: vnodes=$(echo $vnodes|sed 's/\[/ /g'|sed 's/\]/ /g') export LD_LIBRARY_PATH=/opt/shared/nvidia/cuda/lib64:$LD_LIBRARY_PATH mpirun -x LD_LIBRARY_PATH -hostfile $PBS_NODEFILE -np $MPI_NP ./mpi_cuda $vnodes
Передать планировщику:
qsub submit.sh
После завершения файл стандартного вывода будет содержать примерно следующее:
My vnodes: sl002[0] = Node sl002, GPU 0 sl002[1] = Node sl002, GPU 1 sl002[2] = Node sl002, GPU 2 sl003[0] = Node sl003, GPU 0 sl003[1] = Node sl003, GPU 1 sl003[2] = Node sl003, GPU 2 I'm number 1 from 6 and I run on host sl002, gpu 0. I'm number 2 from 6 and I run on host sl002, gpu 1. I'm number 3 from 6 and I run on host sl003, gpu 0. I'm number 0 from 6 and I run on host sl002, gpu 2. I'm number 4 from 6 and I run on host sl003, gpu 1. I'm number 5 from 6 and I run on host sl003, gpu 2. 0 + 0 = 0 2 + 3 = 5 4 + 6 = 10 6 + 9 = 15 400 + 600 = 1000 402 + 603 = 1005 404 + 606 = 1010 406 + 609 = 1015 600 + 900 = 1500 602 + 903 = 1505 604 + 906 = 1510 606 + 909 = 1515 200 + 300 = 500 202 + 303 = 505 204 + 306 = 510 206 + 309 = 515 800 + 1200 = 2000 802 + 1203 = 2005 804 + 1206 = 2010 806 + 1209 = 2015 1000 + 1500 = 2500 1002 + 1503 = 2505 1004 + 1506 = 2510 1006 + 1509 = 2515
CUDA: Начало
Это первая публикация из цикла статей об использовании GPGPU и nVidia CUDA. Планирую писать не очень объемно, чтобы не слишком утомлять читателей, но достаточно часто.
Я предполагаю, что читатель осведомлен, что такое CUDA, если нет, то вводную статью можно найти на Хабре.
Что потребуется для работы:
1. Видеокарта из серии nVidia GeForce 8xxx/9xxx или более современная
2. CUDA Toolkit v.2.1 (скачать можно здесь: www.nvidia.ru/object/cuda_get_ru.html)
3. CUDA SDK v.2.1 (скачать можно там же где Toolkit)
4. Visual Studio 2008
5. CUDA Visual Studio Wizard (скачать можно здесь: sourceforge.net/projects/cudavswizard)
Создание CUDA проекта:
После установки всего необходимого в VS появиться новый вид проекта для С++ с названием CU-DA WinApp, это именно то, что нам надо. В данном типе проекта доступны дополнительные на-стройки для CUDA, позволяющие настроить параметры компиляции под GPU, например версию Compute Capability в зависимости от типа GPU и т.д.
Обычно я создаю чистый проект (Empty Project), так как Precompiled Headers навряд ли пригодиться для CUDA.
Важно отметить, как собирается CUDA приложение. Файлы с расширением *.cpp обрабатываются компилятором MS C++ (cl.exe), а файлы c расширением *.cu компилятором CUDA (nvcc.exe), который в свою очередь определяет, какой код будет работать на GPU, а какой на CPU. Код из *.cu, работающий на CPU, передается на компиляцию MS C++, эту особенность удобно использовать для написания динамических библиотек, которые будут экспортировать функции, использующие для расчетов GPU.
Далее привожу листинг простой программы на CUDA, который выводит на экран информацию об аппаратных возможностях GPU.
Листинг. Программа CudaInfo.
int main()
int deviceCount;
cudaDeviceProp deviceProp;
//Сколько устройств CUDA установлено на PC.
cudaGetDeviceCount(&deviceCount);
printf( «Device count: %d\n\n» , deviceCount);
for ( int i = 0; i < deviceCount; i++)
//Получаем информацию об устройстве
cudaGetDeviceProperties(&deviceProp, i);
//Выводим иформацию об устройстве
printf( «Device name: %s\n» , deviceProp.name);
printf( «Total global memory: %d\n» , deviceProp.totalGlobalMem);
printf( «Shared memory per block: %d\n» , deviceProp.sharedMemPerBlock);
printf( «Registers per block: %d\n» , deviceProp.regsPerBlock);
printf( «Warp size: %d\n» , deviceProp.warpSize);
printf( «Memory pitch: %d\n» , deviceProp.memPitch);
printf( «Max threads per block: %d\n» , deviceProp.maxThreadsPerBlock);
printf( «Max threads dimensions: x = %d, y = %d, z = %d\n» ,
deviceProp.maxThreadsDim[0],
deviceProp.maxThreadsDim[1],
deviceProp.maxThreadsDim[2]);
printf( «Max grid size: x = %d, y = %d, z = %d\n» ,
deviceProp.maxGridSize[0],
deviceProp.maxGridSize[1],
deviceProp.maxGridSize[2]);
printf( «Clock rate: %d\n» , deviceProp.clockRate);
printf( «Total constant memory: %d\n» , deviceProp.totalConstMem);
printf( «Compute capability: %d.%d\n» , deviceProp.major, deviceProp.minor);
printf( «Texture alignment: %d\n» , deviceProp.textureAlignment);
printf( «Device overlap: %d\n» , deviceProp.deviceOverlap);
printf( «Multiprocessor count: %d\n» , deviceProp.multiProcessorCount);
printf( «Kernel execution timeout enabled: %s\n» ,
deviceProp.kernelExecTimeoutEnabled ? «true» : «false» );
>
return 0;
>
* This source code was highlighted with Source Code Highlighter .
В программе я подключаю библиотеку “cuda_runtime_api.h”. Хотя это делать не обязательно, так она инклюдится автоматически, но без неё не будет работать IntelliSence (хотя все равно периодически косячит).
Заключение
Я думаю, что это самый простой способ для написания CUDA-программ, так как требуется минимум усилий для конфигурирования и настройки среды, единственная проблема только с использованием IntelliSence.
В следующий раз будет рассмотрено использование CUDA для математических вычислений и вопросы работы с память видеокарты.
P.S. Задавайте вопросы.
Занятие 3. Установка и настройка рабочего пространства CUDA
Приступая к работе, нужно убедиться, что на вашем рабочем месте, будь то компьютер или ноутбук, присутствует дискретная видеокарта NVIDIA с чипом восьмого поколения G80 (NVIDIA GeForce 8).
Чтобы убедиться, что все условия выполнены, нужно подробно разобрать вопрос с видеокартами восьмого поколения, так сказать, какие модели нам подходят. Сейчас вряд ли у кого-то на компьютере можно обнаружить видеокарту GeForce 8800 GTX или старее, так как данную модель выпустили аж в 2006 году, но тем не менее не будет лишним узнать о том, какие GPU поддерживают CUDA . Полный перечень всех видеокарт можно увидеть на официальной странице NVIDIA :
С аппаратной частью разобрались, теперь переходим к программной.
Из программного обеспечения потребуется среда разработки CUDA Toolkit, которую можно скачать с официального сайта компании NVIDIA ( https://developer.nvidia.com/cuda-toolkit ).
CUDA Toolkit можно установить на Windows, Linux и Mac OSX.
Ссылки на установки по каждой из операционных систем приведены ниже:
Также потребуется стандартный компилятор языка C. Лучше всего использовать Visual Studio 2008 и последующих версий. В связке с Visual Studio при установке Toolkit автоматически прописываются пути в переменной PATH. Выглядит это примерно следующим образом (если вдруг у кого-то автоматически не настроилось):
(Название переменной = Путь)
CUDA_BIN_PATH = С :\Programs\CUDA toolkit 2.0\bin
CUDA_INC_PATH = С :\Programs\CUDA toolkit 2.0\include
CUDA_LIB_PATH = С :\Programs\CUDA toolkit 2.0\lib
NVSDKCUDA_ROOT = С :\Programs\CUDA SDK 2.02.0811.0240
Чтобы при создании нового проекта на Visual Studio появился раздел CUDA нужно выполнить следующие действия.
Зайти в Tools > Options > Projects and Solutions > VC++ Directories
вкладка Executable files добавить новый параметр и ввести :
D:\Programs\CUDA SDK 2.02.0811.0240\bin ,
либо $( CUDA _ BIN _ PATH ) ;
вкладка Include files добавить новый параметр и ввести:
D:\Programs\CUDA toolkit 2.0\include , либо $(CUDA_INC_PATH)
добавить новый параметр и ввести:
D:\Programs\CUDA SDK 2.02.0811.0240\common\inc ,
либо $(NVSDKCUDA_ROOT)\common\inc
вкладка Library files добавить новый параметр и ввести :
D:\Programs\CUDA toolkit 2.0\lib , либо $(CUDA_LIB_PATH)
добавить новый параметр и ввести :
D:\Programs\CUDA SDK 2.02.0811.0240\common\lib ,
либо $( NVSDKCUDA _ ROOT )\ common \ lib
В конечном итоге при создании проекта появится вкладка NVIDIA , в которой будут подразделы с актуальными версиями CUDA :
Итак, мы вооружились всем необходимым и можем приступать к работе.
Помимо работы на локальном компьютере существует возможность работать и вне среды Visual Studio или ей подобной, то есть через удаленное подключение с использованием SSH-клиента. Выбор SSH-клиента уже остается за вами. В данном учебном пособии будут приведены скриншоты из PuTTY 0.70 версии и из WinSCP версии 5.13.
Чтобы проверить, что на вашем компьютере все настроено правильно, нужно через терминал запустить команду:
Данная команда должна отобразить всю информацию по CUDA на вашем устройстве. Должно быть примерно так :
Copyright (c) 2005-2016 NVIDIA Corporation
Built on Tue_Jan_10_13:28:28_CST_2017
Cuda compilation tools, release 8.0, V8.0.61
nvcc:NVIDIA (R) Cuda compiler driver означает , что компилятор CUDA nvcc присутствует в вашей системе .
Cuda compilation tools, release 8.0, V8.0.61 указывает релиз и версию CUDA Toolkit.
Nvidia cuda toolkit что это
CUDA ® – это платформа параллельных вычислений и модель программирования, разработанная NVIDIA. Она позволяет значительно повысить производительность вычислений за счет использования мощности графического процессора (GPU).
CUDA была разработана с учетом нескольких целей проектирования:
- Предоставьте небольшой набор расширений для стандартных языков программирования, таких как C, которые обеспечивают простую реализацию параллельных алгоритмов. С помощью CUDA C/C ++ программисты могут сосредоточиться на задаче распараллеливания алгоритмов, а не тратить время на их реализацию.
- Поддержка разнородных вычислений, при которых приложения используют как центральный процессор, так и графический процессор. Последовательные части приложений выполняются на центральном процессоре, а параллельные части выгружаются на графический процессор. Таким образом, CUDA может постепенно применяться к существующим приложениям. Центральный процессор и графический процессор рассматриваются как отдельные устройства, которые имеют свои собственные области памяти. Эта конфигурация также позволяет выполнять одновременные вычисления на CPU и GPU без конкуренции за ресурсы памяти.
Графические процессоры с поддержкой CUDA имеют сотни ядер, которые могут совместно запускать тысячи вычислительных потоков. Эти ядра имеют общие ресурсы, включая файл регистра и общую память. Встроенная общая память позволяет параллельным задачам, выполняемым на этих ядрах, обмениваться данными, не отправляя их по системной шине памяти.
В этом руководстве показано, как установить и проверить правильность работы средств разработки CUDA.
Функции и основные моменты
- Временная метка графического процессора: временная метка запуска
- Метод: имя метода графического процессора. Это либо “memcpy *” для копий памяти, либо имя ядра графического процессора. Копии памяти имеют суффикс, который описывает тип передачи памяти, например, “memcpyDToHasync” означает асинхронную передачу из памяти устройства в память хоста
- Время работы графического процессора: это время выполнения метода на графическом процессоре
- Процессорное время: это сумма времени работы графического процессора и нагрузки на процессор для запуска этого метода. На уровне данных, генерируемых драйвером, процессорное время – это только нагрузка процессора на запуск метода для неблокирующих методов; для блокирующих методов это сумма времени графического процессора и нагрузки процессора. Все запуски ядра по умолчанию являются неблокирующими. Но если включены какие-либо счетчики профилировщика, запуск ядра блокируется. Запросы на асинхронное копирование памяти в разных потоках не блокируются
- Идентификатор потока: идентификационный номер для потока
- Столбцы только для методов ядра
- Заполняемость: заполняемость – это отношение количества активных деформаций на мультипроцессор к максимальному количеству активных деформаций
- Счетчики профилировщика: список поддерживаемых счетчиков см. в разделе счетчики профилировщика
- размер сетки: количество блоков в сетке по измерениям X, Y и Z отображается в виде [num_blocks_X num_blocks_Y num_blocks_Z] в одном столбце
- размер блока: количество потоков в блоке по измерениям X, Y и Z отображается в виде [num_threads_X num_threads_Y num_threads_Z]] в одном столбце
- dyn smem на блок: динамический размер общей памяти на блок в байтах
- sta smem на блок: статический размер общей памяти на блок в байтах
- регистрация в потоке: количество регистров в потоке
- Столбцы только для методов memcopy
- размер передаваемой памяти: размер передаваемой памяти в байтах
- тип передачи памяти хоста: указывает, используется ли при передаче памяти память с возможностью просмотра страниц или с блокировкой страниц
Проверка установки
Выполните следующие действия для проверки установки −
Шаг 1 − Проверьте версию CUDA toolkit, введя nvcc -V в командной строке.
Шаг 2 − Запустите deviceQuery.cu находится по адресу: C:\ProgramData\NVIDIA Корпорация\CUDA Samples\v9.1\bin\ win64\Release, чтобы просмотреть информацию о вашей видеокарте. Результат будет выглядеть следующим образом −
Шаг 3 − Запустите тест пропускной способности, расположенный по адресу C:\ProgramData\NVIDIA Корпорация\CUDA Samples\v9.1\bin\win64\Release. Это гарантирует, что хост и устройство смогут правильно взаимодействовать друг с другом. Выходные данные будут выглядеть следующим образом−
Если какой-либо из вышеупомянутых тестов завершается неудачей, это означает, что инструментарий не был установлен должным образом. Повторите установку, следуя приведенным выше инструкциям.