Документация

Начало работы со сравнительным тестированием графического процессора

Можно использовать различные оценочные испытания в MATLAB^®, чтобы измерить уровень графического процессора:

Улучшайте производительность Используя вычисления одинарной точности

Можно улучшать производительность графического процессора путем выполнения вычислений в одинарной точности вместо двойной точности. В вычислениях центрального процессора, с другой стороны, вы не получаете это улучшение при переключении от дважды до одинарной точности. Причина состоит в том, что большинство карт графического процессора разработано для графического дисплея, требуя высокую производительность одинарной точности.

Типичные примеры вычислений, подходящих для вычисления с одинарной точностью на графическом процессоре, включают обработку изображений и машинное обучение, видят, например, https://www.mathworks.com/content/dam/mathworks/tag-team/Objects/d/Deep_Learning_in_Cloud_Whitepaper.pdf. Однако другие типы вычислений, такие как проблемы линейной алгебры, обычно требуют обработки двойной точности.

Можно получить повышение производительности до фактора 50 для сингла по сравнению с вычислениями двойной точности, в зависимости от номера карты графического процессора и общего количества ядер. Верхний уровень вычисляет карты, обычно показывают меньшее улучшение. Можно определить повышение производительности конкретного графического процессора при помощи gpuBench, видеть https://www.mathworks.com/matlabcentral/fileexchange/34080-gpubench.

Для всестороннего обзора производительности NVIDIA^® карты графического процессора см. https://en.wikipedia.org/wiki/List_of_Nvidia_graphics_processing_units. Можно вычислить фактор повышения производительности между одинарной точностью и двойной точностью можно следующим образом:

Основной рабочий процесс для того, чтобы улучшать производительность

Цель вычисления графического процессора в MATLAB состоит в том, чтобы ускорить ваши приложения. Эта тема обсуждает основные концепции и методы, которые могут помочь вам достигнуть лучшей производительности на графическом процессоре, таком как настройка оборудования графического процессора и лучшых практик в рамках вашего кода. Это обсуждает компромисс между трудностью с реализацией и производительностью, и описывает критерии, которые вы можете использовать, чтобы выбрать между использованием gpuArray функции, arrayfun, файлы MEX или ядра CUDA. Наконец, это описывает, как точно измерить уровень на графическом процессоре.

При преобразовании кода MATLAB, чтобы работать на графическом процессоре, лучше запускаться с кода MATLAB, который уже выполняет хорошо. В то время как графический процессор и центральный процессор имеют различные показатели производительности, общие руководящие принципы для записи, что хороший код MATLAB также помогает вам записать хороший код MATLAB для графического процессора. Первый шаг должен почти всегда профилировать ваш код центрального процессора. Строки кода, которые профилировщик показывает взятию большей части времени на центральном процессоре, вероятно, будут единицами, которые необходимо сконцентрировать на том, когда вы кодируете для графического процессора.

Является самым легким начать преобразовывать ваше использование кода встроенные функции MATLAB та поддержка gpuArray данные. Эти функции берут входные параметры gpuArray, выполняют вычисления на графическом процессоре и возвращают gpuArray выходные параметры. Список функций MATLAB, которые поддерживают gpuArray данные, найден в Запущенных функциях MATLAB на графическом процессоре. В целом эти функции поддерживают те же аргументы и типы данных как стандартные функции MATLAB, которые вычисляются на центральный процессор.

Если все функции, которые вы хотите использовать, поддерживаются на графическом процессоре, под управлением код по графическому процессору может быть столь же простым как вызов gpuArray, чтобы передать входные данные графическому процессору и вызов gather, чтобы получить выходные данные из графического процессора по окончании. Во многих случаях вы можете должны быть векторизовать свой код, заменив циклично выполненные скалярные операции на матрицу MATLAB и векторные операции. В то время как векторизация обычно является хорошей практикой на центральном процессоре, это обычно очень важно для достижения высокой производительности на графическом процессоре. Для получения дополнительной информации смотрите, Векторизуют для Улучшаемой Производительности графического процессора.

Усовершенствованные инструменты для того, чтобы улучшать производительность

Возможно что даже после преобразования входных параметров к gpuArrays и векторизации вашего кода, существуют операции в вашем алгоритме, которые являются или не встроенные функции, или которые не достаточно быстры, чтобы удовлетворить требования вашего приложения. В таких ситуациях у вас есть три основных опции: используйте arrayfun, чтобы предварительно скомпилировать поэлементные части вашего приложения, использовать библиотечные функции графического процессора или записать пользовательское ядро CUDA.

Если у вас есть чисто поэлементная функция, можно улучшать ее производительность путем вызова ее с arrayfun. Функция arrayfun на графическом процессоре превращает поэлементную функцию MATLAB в пользовательское ядро CUDA, таким образом уменьшая издержки выполнения операции. Часто, существует подмножество вашего приложения, которое может использоваться с arrayfun, даже если целое приложение не может быть. Пример Улучшает Производительность Поэлементного MATLAB® Functions на графическом процессоре с помощью ARRAYFUN, показывает фундаментальные понятия этого подхода; и пример Используя графический процессор, который показывает ARRAYFUN для Симуляций Монте-Карло, как это может быть сделано в симуляциях для финансового приложения.

MATLAB обеспечивает обширную библиотеку поддерживающих графический процессор функций в Parallel Computing Toolbox™, Image Processing Toolbox™, Signal Processing Toolbox™ и других продуктах. Однако существуют многие библиотеки дополнительных функций, которые не имеют прямых встроенных аналогов в поддержке графического процессора MATLAB. Примеры включают библиотеку NVIDIA Performance Primitives и библиотеку CURAND, которые включены в инструментарий CUDA, который поставляется с MATLAB. Если необходимо вызвать функцию в одной из этих библиотек, можно сделать настолько использующий интерфейс GPU MEX. Этот интерфейс позволяет вам извлекать указатели на данные об устройстве из MATLAB gpuArrays так, чтобы можно было передать эти указатели на функции графического процессора. Можно преобразовать возвращенные значения в gpuArrays для возврата к MATLAB. Для получения дополнительной информации смотрите, что MEX-функции Выполнения Содержат Код CUDA.

Наконец, у вас есть опция записи пользовательского ядра CUDA для операции, в которой вы нуждаетесь. Такие ядра могут быть непосредственно интегрированы в MATLAB с помощью объекта CUDAKernel.

Пример, Иллюстрирующий Три Подхода к Вычислению графического процессора: Множество Мандельброта показывает, как реализовать простое вычисление с помощью трех из подходов, упомянутых в этом разделе. Этот пример начинается с кода MATLAB, который легко преобразован, чтобы работать на графическом процессоре, переписывает код, чтобы использовать arrayfun для поэлементных операций, и наконец показывает, как интегрировать пользовательское ядро CUDA для той же операции.

Поочередно, можно записать ядро CUDA как часть файла MEX и вызвать ее с помощью API Во время выполнения CUDA в файле MEX. Любой из этих подходов может позволить вам работать с низкоуровневыми функциями графического процессора, такими как общая память и текстурировать память, которые не непосредственно доступны в коде MATLAB. Для получения дополнительной информации смотрите, что пример Получает доступ к Усовершенствованным Функциям CUDA Используя MEX.

Лучшые практики для того, чтобы улучшать производительность

Измерьте уровень на графическом процессоре

Лучший способ измерить уровень на графическом процессоре состоит в том, чтобы использовать gputimeit. Эта функция берет в качестве входа указатель на функцию без входных параметров и возвращает измеренное время выполнения этой функции. Это заботится о таких факторах сравнительного тестирования как повторение синхронизированной операции, чтобы заставить лучшее разрешение, выполнение функции перед измерением избегать инициализации наверху и вычитания издержки функции синхронизации. Кроме того, gputimeit гарантирует, что все операции на графическом процессоре завершились перед итоговой синхронизацией.

Например, считайте измерение времени взятым, чтобы вычислить факторизацию lu случайного матричного A размера N-by-N. Можно сделать это путем определения функции, которая делает факторизацию lu и передачу указателя на функцию к gputimeit:

A = rand(N,'gpuArray');
fh = @() lu(A);
gputimeit(fh,2); % 2nd arg indicates number of outputs

Можно также измерить уровень с tic и toc. Однако, чтобы получить точную синхронизацию на графическом процессоре, необходимо ожидать операций, чтобы завершиться прежде, чем вызвать toc. Существует два способа сделать это. Можно вызвать gather на итоговом GPU вывод прежде, чем вызвать toc: это обеспечивает все вычисления, чтобы завершиться, прежде чем измерения времени будут проведены. Поочередно, можно использовать функцию wait с объектом gpuDevice как его вход. Например, если вы хотели измерить время, потраченное, чтобы вычислить факторизацию lu матричного A с помощью tic, toc и wait, можно сделать это можно следующим образом:

gd = gpuDevice();
tic();
[l,u] = lu(A);
wait(gd);
tLU = toc();

Можно также использовать профилировщика MATLAB, чтобы показать, как время вычисления распределяется в коде графического процессора. Обратите внимание на то, что, чтобы выполнить измерения синхронизации, профилировщик запускает каждую строку кода независимо, таким образом, она не может составлять наложение (асинхронного) выполнения того, которое может произойти во время нормального функционирования. Для синхронизации целых алгоритмов необходимо использовать tic и toc или gputimeit, как описано выше. Кроме того, профиль не может привести к правильным результатам для пользовательских MEX-функций, если они запускаются асинхронно.

Векторизуйте для улучшаемой производительности графического процессора

Этот пример показывает вам, как улучшать производительность путем выполнения функции на графическом процессоре вместо центрального процессора, и путем векторизации вычислений.

Рассмотрите функцию, которая выполняет быструю свертку на столбцах матрицы. Быстрая свертка, которая является общей операцией в приложениях обработки сигналов, преобразовывает каждый столбец данных от временного интервала до частотного диапазона, умножает ее на преобразование вектора фильтра, преобразовывает назад к временному интервалу и хранит результат в выходной матрице.

function y = fastConvolution(data,filter)
[m,n] = size(data);
% Zero-pad filter to the column length of data, and transform
filter_f = fft(filter,m);

% Create an array of zeros of the same size and class as data
y = zeros(m,n,'like',data);

% Transform each column of data
for ix = 1:n
    af = fft(data(:,ix));
    y(:,ix) = ifft(af .* filter_f);
end
end

Выполните эту функцию в центральном процессоре на данных конкретного размера и измерьте время выполнения с помощью функции timeit MATLAB. Функция timeit заботится об общих факторах сравнительного тестирования, таких как составление запуска и наверху.

a = complex(randn(4096,100),randn(4096,100));  % Data input
b = randn(16,1);                               % Filter input
c = fastConvolution(a,b);                      % Calculate output
ctime = timeit(@()fastConvolution(a,b));       % Measure CPU time
disp(['Execution time on CPU = ',num2str(ctime)]);

На демонстрационной машине этот код отображает вывод:

Execution time on CPU = 0.019335

Теперь выполните эту функцию на графическом процессоре. Можно сделать это легко путем изменения входных данных, чтобы быть gpuArrays, а не нормальными массивами MATLAB. Синтаксис 'like', используемый при создании вывода в функции, гарантирует, что y будет gpuArray, если data будет gpuArray.

ga = gpuArray(a);                              % Move array to GPU
gb = gpuArray(b);                              % Move filter to GPU
gc = fastConvolution(ga,gb);                   % Calculate on GPU
gtime = gputimeit(@()fastConvolution(ga,gb));  % Measure GPU time
gerr = max(max(abs(gather(gc)-c)));            % Calculate error
disp(['Execution time on GPU = ',num2str(gtime)]);
disp(['Maximum absolute error = ',num2str(gerr)]);

На той же машине этот код отображает вывод:

Execution time on CPU = 0.019335
Execution time on GPU = 0.027235
Maximum absolute error = 1.1374e-14

К сожалению, графический процессор медленнее, чем центральный процессор для этой проблемы. Причина состоит в том, что for - цикл выполняет БПФ, умножение и обратные операции FFT на отдельных столбцах длины 4096. Лучший способ увеличить производительность состоит в том, чтобы векторизовать код, так, чтобы один вызов функции MATLAB выполнил больше вычисления. Операции FFT и IFFT легко векторизовать: fft(A) вычисляет БПФ каждого столбца матричного A. Можно выполнить умножение фильтра с каждым столбцом в матрице целиком с помощью двоичного файла MATLAB скалярная функция расширения bsxfun. Векторизованная функция выглядит так:

function y = fastConvolution_v2(data,filter)
m = size(data,1);
% Zero-pad filter to the length of data, and transform
filter_f = fft(filter,m);

% Transform each column of the input
af = fft(data);

% Multiply each column by filter and compute inverse transform
y = ifft(bsxfun(@times,af,filter_f));
end

Выполните тот же эксперимент с помощью векторизованной функции:

a = complex(randn(4096,100),randn(4096,100));   % Data input
b = randn(16,1);                                % Filter input
c = fastConvolution_v2(a,b);                    % Calculate output
ctime = timeit(@()fastConvolution_v2(a,b));     % Measure CPU time
disp(['Execution time on CPU = ',num2str(ctime)]);

ga = gpuArray(a);                               % Move data to GPU
gb = gpuArray(b);                               % Move filter to GPU
gc = fastConvolution_v2(ga, gb);                % Calculate on GPU
gtime = gputimeit(@()fastConvolution_v2(ga,gb));% Measure GPU time
gerr = max(max(abs(gather(gc)-c)));             % Calculate error
disp(['Execution time on GPU = ',num2str(gtime)]);
disp(['Maximum absolute error = ',num2str(gerr)]);

Execution time on CPU = 0.010393
Execution time on GPU = 0.0020537
Maximum absolute error = 1.1374e-14

В заключение векторизация кода помогает и версиям центрального процессора и графического процессора запуститься быстрее. Однако векторизация помогает версии графического процессора намного больше, чем центральный процессор. Улучшенная версия ЦП почти дважды с такой скоростью, как оригинал; улучшенная версия графического процессора в 13 раз быстрее, чем оригинал. Код графического процессора пошел от того, чтобы быть на 40% медленнее, чем центральный процессор в исходной версии, приблизительно к в пять раз быстрее в исправленной версии.

Поиск и устранение проблем графические процессоры

Если у вас только есть один графический процессор в вашей машине, то вероятно, что ваша видеокарта также действует как ваша видеокарта. В этом случае ваш графический процессор, вероятно, подвергается тайм-ауту, наложенному операционной системой (OS). Можно исследовать это на графический процессор можно следующим образом:

gpuDevice

ans =

...

KernelExecutionTimeout: 1