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

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

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

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

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

Типичные примеры вычислений, подходящих для расчета с одинарной точностью на графическом процессоре, включают обработку изображений и машинное обучение, видят e.g. 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- 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

Выполните эту функцию в центральном процессоре на данных конкретного размера и измерьте время выполнения с помощью MATLAB timeit функция. 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