Программно - аппаратный стек CUDA. Иерархия памяти.

Лекция 2
Программно-аппаратный стек
CUDA. Иерархия памяти.
Глобальная память.
Перепѐлкин Е.Е.
CUDA
Compute Unified Device Architecture
Особенности GPU
• GPU (device) это вычислительное
устройство, которое:
• Является сопроцессором к CPU (host)
• Имеет собственную память (DRAM)
• Выполняет одновременно очень много нитей
• Отличия нитей между CPU и GPU
• Нити на GPU очень «легкие»
• HW планировщик задач
• Для полноценной загрузки GPU нужны тысячи
нитей
• Для покрытия латентностей операций чтения / записи
• Для покрытия латентностей sfu инструкций
Гетерогенная структура кода
• Код состоит как из последовательных, так и из
параллельных частей
• Последовательные части кода выполняются на CPU
• Массивно-параллельные части кода выполняются на
GPU как функция-ядро ( kernel function )
Последовательный код
Параллельное ядро A
KernelA<<< nBlk, nTid >>>(args);
…
Последовательный код
Параллельное ядро B
KernelB<<< nBlk, nTid >>>(args);
…
Потоки CUDA
• Ядро CUDA исполняется массивом потоков
• Все потоки исполняют одну программу
• Каждый поток использует свой индекс для
вычислений и управления исполнением
threadID
0 1 2 3 4 5 6 7
…
float x =
input[threadID];
float y = func(x);
output[threadID] = y;
…
Взаимодействие потоков
• Потоки могут быть не полностью независимы
• Обмениваются результатами вычислений
• Разделяют доступ к внешней памяти
• Возможность взаимодействия потоков –
ключевая особенность программной модели
CUDA
•
Потоки кооперируются, используя разделяемую
память и примитивы синхронизации
Масштабируемость
• Монолитный массив потоков разделяется на блоки
• Потоки внутри блока взаимодействуют через разделяемую
память
• Потоки в разных блоках не могут синхронизироваться
• Позволяет программам прозрачно масштабироваться
Блок 0
threadID
0 1 2 3 4 5 6
Блок 1
7
…
float x =
input[threadID];
float y = func(x);
output[threadID] = y;
…
0 1 2 3 4 5 6
Блок N-1
0 1 2 3 4 5 6
7
…
float x =
input[threadID];
float y = func(x);
output[threadID] = y;
…
…
7
…
float x =
input[threadID];
float y = func(x);
output[threadID] = y;
…
Прозрачная масштабируемость
• Блоки могут быть распределены на любой процессор
SM
• код на CUDA масштабируется на любое количество
ядер
SM
время
Блок 0
Блок 2
SM
Блок 1
Сетка блоков
Блок 0
Блок 1
Блок 2
Блок 3
Блок 4
Блок 5
Блок 6
Блок 7
Блок 3
Блок 4
Блок 5
Блок 6
Блок 7
SM
SM
SM
SM
Блок 0
Блок 1
Блок 2
Блок 3
Блок 4
Блок 5
Блок 6
Блок 7
время
Устройство B
Устройство A
Иерархия нитей
• Параллельная часть кода выполняется как
большое количество нитей ( threads )
• Нити группируются в блоки ( blocks )
фиксированного размера ( blockDim )
• Блоки объединяются в сеть блоков ( grid )
• Ядро выполняется на сетке из блоков
• Каждая нить и блок имеют свой уникальный
идентификатор ( threadIdx и blockIdx )
SIMT (Single Instruction, Multiple Threads)
•
•
•
•
Параллельно на каждом SM выполняется
большое число отдельных нитей (threads)
Нити подряд разбиваются на warp’ы (по 32
нити) и SM управляет выполнением warp’ов
Нити в пределах одного warp’а
выполняются физически параллельно
Большое число warp’ов покрывает
латентность
CUDA «Hello World»
#define N
(1024*1024)
__global__ void kernel ( float * data )
{
[0…2047]
[512]
[0…511]
int
idx = blockIdx.x * blockDim.x + threadIdx.x;
float x
= 2.0f * 3.1415926f * (float) idx / (float) N;
data [idx] = sinf ( sqrtf ( x ) );
}
int main ( int argc, char * argv [] )
{
float * a;
float * dev = NULL;
a = ( float* ) malloc (N * sizeof ( float ) );
cudaMalloc ( (void**)&dev, N * sizeof ( float ) );
kernel<<<N/512, 512>>> ( dev );
cudaMemcpy ( a, dev, N * sizeof ( float ), cudaMemcpyDeviceToHost );
for (int idx = 0; idx < N; idx++)
free(a); cudaFree(dev);
return 0;
}
printf("a[%d] = %.5f\n", idx, a[idx]);
Топология сети ( grid )
• Потоки в CUDA объединяются в блоки:
• Возможна 1D, 2D, 3D топология блока и нитей
• Общее кол-во потоков в блоке ограничено
• В Tesla 10 максимальное число потоков в блоке 512 (1024)
• В Tesla 20 – 1536 потоков (?)
Номер нити в сети
• Размер 3D блока
• (Dx,Dy,Dz) → (blockDim.x, blockDim.y,
blockDim.z)
• Координаты 3D нити внутри блока
• (x,y,z) → (threadIdx.x, threadIdx.y, threadIdx.z)
• Глобальный номер нити (потока) в блоке
• ID thread = x + y * Dx + z * Dx * Dy
Программная модель CUDA
• Выбор топологии сети ( grid )
1D
2D
3D
for (int ix = 0; ix < nx; ix++)
{
pData[ix] = f(ix);
}
for (int ix = 0; ix < nx; ix++)
for (int iy = 0; iy < ny; iy++)
{
pData[ix + iy * nx] = f(ix) * g(iy);
}
for (int ix = 0; ix < nx; ix++)
for (int iy = 0; iy < ny; iy++)
for (int iz = 0; iz < nz; iz++)
{
pData[ix + (iy + iz * ny) * nx] = f(ix) * g(iy) * h(iz);
}
Смысл разбиения на блоки
• Размер блока ограничен
• Блоки могут использовать shared память
• Так как блок целиком выполняется на одном SM
• Объем shared памяти ограничен и зависит от HW
• Внутри блока потоки могут
синхронизироваться
• Так как блок целиком выполняется на одном SM
Выбор топологии
•
1D: обработка аудио
•
2D: обработка изображений и видео
•
3D: физическое моделирование
Синтаксис CUDA
• CUDA – это расширение языка C
•
•
•
•
[+] спецификаторы для функций и переменных
[+] новые встроенные типы
[+] встроенные переменные (внутри ядра)
[+] директива для запуска ядра из C кода
• Как скомпилировать CUDA код
• [+] nvcc компилятор
• [+] .cu расширение файла
CUDA спецификаторы
• Спецификатор функций
Спецификатор
Выполняется на
Может вызываться из
__device__
device
device
__global__
device
host
__host__
host
host
• Спецификатор переменных
Спецификатор
Находится
Доступна
Вид доступа
__device__
device
device
R
__constant__
device
device / host
__shared__
device
block
R/W
RW /
__syncthreads()
Расширения языка C
• Спецификатор __global__ соответствует
ядру
• Может возвращать только void
• Спецификаторы __host__ и __device__
могут использоваться одновременно
• Компилятор сам создаст версии для CPU и
GPU
• Спецификаторы __global__ и __host__ не
могут быть использованы одновременно
Расширения языка C
• Новые типы данных:
• 1/2/3/4-мерные вектора из базовых типов
• (u)char, (u)int, (u)short, (u)long, longlong
• float, double
• dim3 – uint3 с нормальным конструктором,
позволяющим задавать не все компоненты
• Не заданные инициализируются единицей
Расширения языка С
int2
float4
float2
dim3
dim3
a = make_int2 (
b = make_float4
x = make_float2
grid
= dim3 (
blocks = dim3 (
1, 7 );
( a.x, a.y, 1.0f, 7 );
( b.z, b.w );
10 );
16, 16 );
Для векторов не определены покомпонентные
операции
Для double и longlong возможны только
вектора размера 1 и 2.
Встроенные переменные
• В любом CUDA kernel’e доступны:
•
•
•
•
•
dim3 gridDim;
uint3 blockIdx;
dim3 blockDim;
uint3 threadIdx;
int warpSize;
dim3 – встроенный тип,
который используется для
задания размеров kernel’а
По сути – это uint3.
Директивы запуска ядра
• Как запустить ядро с общим кол-во нитей
равным nx?
float * pData;
dim3 threads(256, 1, 1);
dim3 blocks(nx / 256, 1);
Неявно предпологаем,
что nx кратно 256
incKernel<<<blocks, threads>>> ( pData );
<<< , >>>
угловые скобки, внутри которых задаются
параметры запуска ядра:
• Кол-во блоке в сетке
• Кол-во потоков в блоке
•…
Расширения языка С
Общий вид команды для запуска ядра
incKernel<<<bl, th, ns, st>>> ( data );
• bl – число блоков в сетке
• th – число нитей в блоке
• ns – количество дополнительной sharedпамяти, выделяемое блоку
• st – поток, в котором нужно запустить ядро
Как скомпилировать CUDA код
• NVCC – компилятор для CUDA
• Основными опциями команды nvcc являются:
• --use_fast_math - заменить все вызовы стандартных
математических функций (например, sin ) на их
быстрые (но менее точные) аналоги (__sin )
• -o <outputFileName> - задать имя выходного файла
• CUDA файлы обычно носят расширение .cu
Компиляция программ
• Используем утилиту make/nmake, явно
вызывающую nvcc
• Используем MS Visual Studio
• Подключаем cuda.rules
• Используем CUDA Wizard
(http://sourceforge.net/projects/cudawizard)
Процесс сборки приложения
Код на
C CUDA
С код для CPU
NVCC
Компилятор
для CPU
Объектные
файлы CUDA
Объектные
файлы CPU
Сборка
Общий
исполняемый
файл CPU-GPU
Основы CUDA host API
• Два API
• Низкоуровневый driver API (cu*)
• Высокоуровневый runtime API (cuda*)
• Реализован через driver API
• Не требуют явной инициализации
• Все функции возвращают значение типа
cudaError_t
• cudaSuccess в случае успеха
Основы CUDA API
•
•
•
•
•
Многие функции API асинхронны:
Запуск ядра
Копирование при помощи функций Async
Копирование device <-> device
Инициализация памяти
Типы памяти в CUDA
Тип памяти Доступ
Регистры
R/W
Уровень
Скорость работы
выделения
Per-thread Высокая(on-chip)
Локальная
Constant
R/W
R/W
R/W
R/O
Per-thread
Per-block
Per-grid
Per-grid
Низкая (DRAM)
Высокая(on-chip)
Низкая (DRAM)
Высокая(L1 cache)
Texture
R/O
Per-grid
Высокая(L1 cache)
Shared
Глобальная
Пространство памяти CUDA
• constant
• texture
• L1 cache
Блок (0, 0)
Блок(1, 0)
Разделяемая память
Регистры
Поток(0, 0)
Локальная
память
Регистры
Поток (1, 0)
Локальная
память
Разделяемая память
Регистры
Поток(0, 0)
Локальная
память
Глобальная память
Host
DRAM
Регистры
Поток (1, 0)
Локальная
память
Типы памяти в CUDA
• Самая быстрая – shared (on-chip) и регистры
• Самая медленная – глобальная (DRAM)
• Для ряда случаев можно использовать
кэшируемую константную и текстурную
память
• Доступ к памяти в CUDA идет отдельно для
• каждой половины warp’а (half-warp) Tesla 10
• warp’a (Tesla 20)
Работа с памятью в CUDA
• Основа оптимизации – оптимизация
работы с памятью
• Максимальное использование sharedпамяти
• Использование специальных паттернов
доступа к памяти, гарантирующих
эффективный доступ
• Паттерны работают независимо в
пределах каждого half-warp’а / warp’а
Работа с глобальной памятью в CUDA
cudaError_t cudaMalloc
( void ** devPtr, size_t size );
cudaError_t cudaMallocPitch ( void ** devPtr,
size_t *pitch, size_t width, size_t height );
cudaError_t cudaFree ( void * devPtr );
cudaError_t cudaMemcpy ( void * dst, const void * src,
size_t count, enum cudaMemcpyKind kind );
cudaError_t cudaMemcpyAsync ( void * dst,
const void * src, size_t count,
enum cudaMemcpyKind kind,
cudaStream_t stream );
cudaError_t cudaMemset ( void * devPtr, int value,
size_t count );
Работа с глобальной памятью в CUDA
Пример работы с глобальной памятью
float * devPtr;
// pointer device memory
// allocate device memory
cudaMalloc ( (void **) &devPtr, 256*sizeof ( float );
// copy data from host to device memory
cudaMemcpy ( devPtr, hostPtr, 256*sizeof ( float ),
cudaMemcpyHostToDevice );
// process data
// copy results from device to host
cudaMemcpy ( hostPtr, devPtr, 256*sizeof( float ),
cudaMemcpyDeviceToHost );
// free device memory
cudaFree
( devPtr );
Пример: умножение матриц
• Произведение двух квадратных матриц A и B
размера N*N, N кратно 16
• Матрицы расположены в глобальной памяти
• По одной нити на каждый элемент Ci,j
• 2D блок – 16*16
B
• 2D grid
B
k,j
A
Ai,k
C
Ci,j
Умножение матриц
#define BLOCK_SIZE 16
__global__ void matMult ( float * a, float * b, int n,
float * c )
{
int
bx = blockIdx.x;
int
by = blockIdx.y;
int
tx = threadIdx.x;
int
ty = threadIdx.y;
float sum = 0.0f;
int
ia = n * BLOCK_SIZE * by + n * ty;
int
ib = BLOCK_SIZE * bx + tx;
int
ic = n * BLOCK_SIZE * by + BLOCK_SIZE * bx;
for ( int k = 0; k < n; k++ )
sum += a [ia + k] * b [ib + k*n];
c [ic + n * ty + tx] = sum;
}
Умножение матриц
int
float
dim3
dim3
numBytes = N * N * sizeof ( float );
* adev, * bdev, * cdev ;
threads ( BLOCK_SIZE, BLOCK_SIZE );
blocks ( N / threads.x, N / threads.y);
cudaMalloc
cudaMalloc
cudaMalloc
( (void**)&adev, numBytes ); // allocate DRAM
( (void**)&bdev, numBytes ); // allocate DRAM
( (void**)&cdev, numBytes ); // allocate DRAM
// copy from CPU to DRAM
cudaMemcpy ( adev, a, numBytes, cudaMemcpyHostToDevice );
cudaMemcpy ( bdev, b, numBytes, cudaMemcpyHostToDevice );
matMult<<<blocks, threads>>> ( adev, bdev, N, cdev );
cudaThreadSynchronize();
cudaMemcpy
( c, cdev, numBytes, cudaMemcpyDeviceToHost );
cudaFree
cudaFree
cudaFree
( adev );
( bdev );
( cdev );
Простейшая реализация.
• На каждый элемент
• 2*N арифметических операций
• 2*N обращений к глобальной памяти
• Memory bound (тормозит именно доступ к
памяти)
Используем CUDA Profiler
• Легко видно, что основное время (84.15%)
ушло на чтение из глобальной памяти
• Непосредственно вычисления заняли всего
около 10%
CUDA Compute Capability
• Возможности GPU обозначаются при
помощи Compute Capability, например 1.1
• Старшая цифра соответствует архитектуре
• Младшая – небольшим архитектурным
изменениям
• Можно получить из полей major и minor
структуры cudaDeviceProp
Получение информации о GPU
int main ( int argc, char * argv [] )
{
int
deviceCount;
cudaDeviceProp
devProp;
cudaGetDeviceCount ( &deviceCount );
printf
( "Found %d devices\n", deviceCount );
for ( int device = 0; device < deviceCount; device++ )
{
cudaGetDeviceProperties ( &devProp, device );
printf ( "Device %d\n", device );
printf ( "Compute capability
: %d.%d\n", devProp.major, devProp.minor );
printf ( "Name
: %s\n", devProp.name );
printf ( "Total Global Memory
: %d\n", devProp.totalGlobalMem );
printf ( "Shared memory per block: %d\n", devProp.sharedMemPerBlock );
printf ( "Registers per block
: %d\n", devProp.regsPerBlock );
printf ( "Warp size
: %d\n", devProp.warpSize );
printf ( "Max threads per block : %d\n", devProp.maxThreadsPerBlock );
printf ( "Total constant memory : %d\n", devProp.totalConstMem );
}
return 0;
}
Compute Capability
GPU
Compute Capability
Tesla S2070/C2070/2090
2.0/2.1
Tesla S1070/C1060
1.3
GeForce GTX 260
GeForce 9800 GX2
1.3
1.1
GeForce 9800 GTX
1.1
GeForce 8800 GT
1.1
GeForce 8800 GTX
1.0
RTM Appendix A.1 CUDA Programming Guide
Compute Capability
• Compute Caps. – доступная версия CUDA
• Разные возможности HW
• Пример:
•
•
•
•
в 1.1 добавлены атомарные операции в global memory
в 1.2 добавлены атомарные операции в shared memory
в 1.3 добавлены вычисления в double
в 2.0 добавлены управление кэшем и др. операции
• Узнать доступный Compute Caps. можно через
cudaGetDeviceProperties ()
• См. CUDAHelloWorld
• Сегодня Compute Caps:
• Влияет на правила работы с глобальной памятью
Объединение запросов
• GPU умеет объединять ряд запросов к
глобальной памяти в один блок (транзакцию)
• Независимо происходит для каждого halfwarp’а / warp’а ( CC 1.x / 2.x )
GPU с CC 1.0/1.1
• Нити обращаются к
• 32-битовым словам, давая 64-байтовый блок
• 64-битовым словам, давая 128-байтовый блок
• Все 16 слов лежат в пределах блока
• k-ая нить half-warp’а обращается к k-му
слову блока
• Блок выровнен
GPU с CC 1.0/1.1
Thread 0
Address 128
Thread 0
Address 128
Thread 1
Address 132
Thread 1
Address 132
Thread 2
Address 136
Thread 2
Address 136
Thread 3
Address 140
Thread 3
Address 140
Thread 4
Address 144
Thread 4
Address 144
Thread 5
Address 148
Thread 5
Address 148
Thread 6
Address 152
Thread 6
Address 152
Thread 7
Address 156
Thread 7
Address 156
Thread 8
Address 160
Thread 8
Address 160
Thread 9
Address 164
Thread 9
Address 164
Thread 10
Address 168
Thread 10
Address 168
Thread 11
Address 172
Thread 11
Address 172
Thread 12
Address 176
Thread 12
Address 176
Thread 13
Address 180
Thread 13
Address 180
Thread 14
Address 184
Thread 14
Address 184
Thread 15
Address 188
Thread 15
Address 188
Coalescing
GPU с CC 1.0/1.1
Thread 0
Address 128
Thread 0
Address 128
Thread 1
Address 132
Thread 1
Address 132
Thread 2
Address 136
Thread 2
Address 136
Thread 3
Address 140
Thread 3
Address 140
Thread 4
Address 144
Thread 4
Address 144
Thread 5
Address 148
Thread 5
Address 148
Thread 6
Address 152
Thread 6
Address 152
Thread 7
Address 156
Thread 7
Address 156
Thread 8
Address 160
Thread 8
Address 160
Thread 9
Address 164
Thread 9
Address 164
Thread 10
Address 168
Thread 10
Address 168
Thread 11
Address 172
Thread 11
Address 172
Thread 12
Address 176
Thread 12
Address 176
Thread 13
Address 180
Thread 13
Address 180
Thread 14
Address 184
Thread 14
Address 184
Thread 15
Address 188
Thread 15
Address 188
Not Coalescing
GPU с CC 1.2/1.3
• Нити обращаются к
• 8-битовым словам, дающим один 32-байтовый
сегмент
• 16-битовым словам, дающим один 64-байтовый
сегмент
• 32-битовым словам, дающим один 128-байтовый
сегмент
• Получающийся сегмент выровнен по своему
размеру
Coalescing
• Если хотя бы одно условие не выполнено
• 1.0/1.1 – 16 отдельных транзакций
• 1.2/1.3 – объединяет их в блоки (2,3,…) и для
каждого блока проводится отдельная
транзакция
• Для 1.2/1.3 порядок в котором нити
обращаются к словам внутри блока не имеет
значения (в отличии от 1.0/1.1)
Объединение для GPU с CC 1.2/1.3
1 транзакция - 64B
2 транзакции - 64B и 32B
1 транзакция - 128B
Fermi – Подсистема памяти
• Настраиваемый L1 кэш
для каждого SM
CUDA
нить
• 16КБ SMEM, 48КБ L1
• 48КБ SMEM, 16КБ L1
Shared Memory
L1 cache
• Общий L2 кэш для всех
SM
• 768КБ
• Атомарные операции
L2 cache
• 20x быстрее чем на Tesla
• ЕСС, коррекция ошибок
DRAM
• Single-Error Detect
• Double-Error Correct
Coalescing CC 2.0
• Флаги компиляции
• использовать L1 и L2: -Xptxas –dlcm=ca
• использовать L2: -Xptxas –dlcm=cg
• Кэш линия 128 байт и выравнивание
по 128 байт в глобальной памяти
• Объединения происходит на уровне
warp’ов
Coalescing CC 2.0
• Объединение запросов в память для 32 нитей
• L1 включен – всегда идут запросы по 128B c
кэшированием в L1
2 транзакции - 2 x 128B
следующий варп скорей всего только 1 транзакция,
так как попадаем в L1
Coalescing CC 2.0
• L1 выключен – всегда идут запросы по 32B
• Лучше для разреженного доступа к памяти
32 транзакции по 32B, вместо 32 x 128B
…
…
Coalescing
• Можно добиться заметного увеличения
скорости работы с памятью
• Лучше использовать не массив структур,
а набор массивов отдельных компонент –
это позволяет использовать coalescing
Использование отдельных массивов
struct vec3
{
float x, y, z;
};
vec3 * a;
Не можем использовать
coalescing при чтении данных
float x = a [threadIdx.x].x;
float y = a [threadIdx.x].y;
float z = a [threadIdx.x].z;
float * ax, * ay, * az;
float x = ax [threadIdx];
float y = ay [threadIdx];
float z = az [threadIdx];
Поскольку нити одновременно
обращаются к последовательно
лежащим словам памяти, то
будет происходить coalescing
Pinned-память
CUDA 3.2
CUDA 4.0
malloc(a)
cudaMallocHost(b)
memcpy(b, a)
cudaHostRegister(a)
работаем с a
memcpy(a, b)
cudaFreeHost(b)
cudaHostUnregister(a)