Вычисления на графических процессорах

Технология CUDA (англ. Compute Unified Device Architecture) - программно-аппаратная архитектура, позволяющая производить вычисления с использованием графических процессоров NVIDIA, поддерживающих технологию GPGPU (произвольных вычислений на видеокартах). Архитектура CUDA впервые появились на рынке с выходом чипа NVIDIA восьмого поколения - G80 и присутствует во всех последующих сериях графических чипов, которые используются в семействах ускорителей GeForce, ION, Quadro и Tesla.

CUDA SDK позволяет программистам реализовывать на специальном упрощённом диалекте языка программирования Си алгоритмы, выполнимые на графических процессорах NVIDIA и включать специальные функции в текст программы на Cи. CUDA даёт разработчику возможность по своему усмотрению организовывать доступ к набору инструкций графического ускорителя и управлять его памятью, организовывать на нём сложные параллельные вычисления.

История

В 2003 г. Intel и AMD участвовали в совместной гонке за самый мощный процессор. За несколько лет в результате этой гонки тактовые частоты существенно выросли, особенно после выхода Intel Pentium 4.

После прироста тактовых частот (между 2001 и 2003 гг. тактовая частота Pentium 4 удвоилась с 1,5 до 3 ГГц), а пользователям пришлось довольствоваться десятыми долями гигагерц, которые вывели на рынок производители (с 2003 до 2005 гг.тактовые частоты увеличились 3 до 3,8 ГГц).

Архитектуры, оптимизированные под высокие тактовые частоты, та же Prescott, так же стали испытывать трудности, и не только производственные. Производители чипов столкнулись с проблемами преодоления законов физики. Некоторые аналитики даже предрекали, что закон Мура перестанет действовать. Но этого не произошло. Оригинальный смысл закона часто искажают, однако он касается числа транзисторов на поверхности кремниевого ядра. Долгое время повышение числа транзисторов в CPU сопровождалось соответствующим ростом производительности - что и привело к искажению смысла. Но затем ситуация усложнилась. Разработчики архитектуры CPU подошли к закону сокращения прироста: число транзисторов, которое требовалось добавить для нужного увеличения производительности, становилось всё большим, заводя в тупик.

Причина, по которой производителям GPU не столкнулись с этой проблемой очень простая: центральные процессоры разрабатываются для получения максимальной производительности на потоке инструкций, которые обрабатывают разные данные (как целые числа, так и числа с плавающей запятой), производят случайный доступ к памяти и т.д. До сих пор разработчики пытаются обеспечить больший параллелизм инструкций - то есть выполнять как можно большее число инструкций параллельно. Так, например, с Pentium появилось суперскалярное выполнение, когда при некоторых условиях можно было выполнять две инструкции за такт. Pentium Pro получил внеочередное выполнение инструкций, позволившее оптимизировать работу вычислительных блоков. Проблема заключается в том, что у параллельного выполнения последовательного потока инструкций есть очевидные ограничения, поэтому слепое повышение числа вычислительных блоков не даёт выигрыша, поскольку большую часть времени они всё равно будут простаивать.

Работа GPU относительно простая. Она заключается в принятии группы полигонов с одной стороны и генерации группы пикселей с другой. Полигоны и пиксели независимы друг от друга, поэтому их можно обрабатывать параллельно. Таким образом, в GPU можно выделить крупную часть кристалла на вычислительные блоки, которые, в отличие от CPU, будут реально использоваться.

GPU отличается от CPU не только этим. Доступ к памяти в GPU очень связанный - если считывается тексель, то через несколько тактов будет считываться соседний тексель; когда записывается пиксель, то через несколько тактов будет записываться соседний. Разумно организуя память, можно получить производительность, близкую к теоретической пропускной способности. Это означает, что GPU, в отличие от CPU, не требуется огромного кэша, поскольку его роль заключается в ускорении операций текстурирования. Всё, что нужно, это несколько килобайт, содержащих несколько текселей, используемых в билинейных и трилинейных фильтрах.

Первые расчёты на GPU

Самые первые попытки такого применения ограничивались использованием некоторых аппаратных функций, таких, как растеризация и Z-буферизация. Но в нынешнем веке, с появлением шейдеров, начали ускорять вычисления матриц. В 2003 г. на SIGGRAPH отдельная секция была выделена под вычисления на GPU, и она получила название GPGPU (General-Purpose computation on GPU) - универсальные вычисления на GPU).

Наиболее известен BrookGPU - компилятор потокового языка программирования Brook, созданный для выполнения неграфических вычислений на GPU. До его появления разработчики, использующие возможности видеочипов для вычислений, выбирали один из двух распространённых API: Direct3D или OpenGL. Это серьёзно ограничивало применение GPU, ведь в 3D графике используются шейдеры и текстуры, о которых специалисты по параллельному программированию знать не обязаны, они используют потоки и ядра. Brook смог помочь в облегчении их задачи. Эти потоковые расширения к языку C, разработанные в Стэндфордском университете, скрывали от программистов трёхмерный API, и представляли видеочип в виде параллельного сопроцессора. Компилятор обрабатывал файл.br с кодом C++ и расширениями, производя код, привязанный к библиотеке с поддержкой DirectX, OpenGL или x86.

Появление Brook вызвал интерес у NVIDIA и ATI и в дальнейшем, открыл целый новый его сектор - параллельные вычислители на основе видеочипов.

В дальнейшем, некоторые исследователи из проекта Brook перешли в команду разработчиков NVIDIA, чтобы представить программно-аппаратную стратегию параллельных вычислений, открыв новую долю рынка. И главным преимуществом этой инициативы NVIDIA стало то, что разработчики отлично знают все возможности своих GPU до мелочей, и в использовании графического API нет необходимости, а работать с аппаратным обеспечением можно напрямую при помощи драйвера. Результатом усилий этой команды стала NVIDIA CUDA.

Области применения параллельных расчётов на GPU

При переносе вычислений на GPU, во многих задачах достигается ускорение в 5-30 раз, по сравнению с быстрыми универсальными процессорами. Самые большие цифры (порядка 100-кратного ускорения и даже более!) достигаются на коде, который не очень хорошо подходит для расчётов при помощи блоков SSE, но вполне удобен для GPU.

Это лишь некоторые примеры ускорений синтетического кода на GPU против SSE-векторизованного кода на CPU (по данным NVIDIA):

Флуоресцентная микроскопия: 12x.

Молекулярная динамика (non-bonded force calc): 8-16x;

Электростатика (прямое и многоуровневое суммирование Кулона): 40-120x и 7x.

Таблица, которую NVIDIA, показывает на всех презентациях, в которой показывается скорость графических процессоров относительно центральных.

Перечень основных приложений, в которых применяются вычисления на GPU: анализ и обработка изображений и сигналов, симуляция физики, вычислительная математика, вычислительная биология, финансовые расчёты, базы данных, динамика газов и жидкостей, криптография, адаптивная лучевая терапия, астрономия, обработка звука, биоинформатика, биологические симуляции, компьютерное зрение, анализ данных (data mining), цифровое кино и телевидение, электромагнитные симуляции, геоинформационные системы, военные применения, горное планирование, молекулярная динамика, магнитно-резонансная томография (MRI), нейросети, океанографические исследования, физика частиц, симуляция свёртывания молекул белка, квантовая химия, трассировка лучей, визуализация, радары, гидродинамическое моделирование (reservoir simulation), искусственный интеллект, анализ спутниковых данных, сейсмическая разведка, хирургия, ультразвук, видеоконференции.

Преимущества и ограничения CUDA

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

Чтобы перенести вычисления на GPU в рамках такой модели, нужен специальный подход. Даже поэлементное сложение двух векторов потребует отрисовки фигуры на экране или во внеэкранный буфер. Фигура растеризуется, цвет каждого пикселя вычисляется по заданной программе (пиксельному шейдеру). Программа считывает входные данные из текстур для каждого пикселя, складывает их и записывает в выходной буфер. И все эти многочисленные операции нужны для того, что в обычном языке программирования записывается одним оператором!

Поэтому, применение GPGPU для вычислений общего назначения имеет ограничение в виде слишком большой сложности обучения разработчиков. Да и других ограничений достаточно, ведь пиксельный шейдер - это всего лишь формула зависимости итогового цвета пикселя от его координаты, а язык пиксельных шейдеров - язык записи этих формул с Си-подобным синтаксисом. Ранние методы GPGPU являются хитрым трюком, позволяющим использовать мощность GPU, но без всякого удобства. Данные там представлены изображениями (текстурами), а алгоритм - процессом растеризации. Нужно особо отметить и весьма специфичную модель памяти и исполнения.

Программно-аппаратная архитектура для вычислений на GPU компании NVIDIA отличается от предыдущих моделей GPGPU тем, что позволяет писать программы для GPU на настоящем языке Си со стандартным синтаксисом, указателями и необходимостью в минимуме расширений для доступа к вычислительным ресурсам видеочипов. CUDA не зависит от графических API, и обладает некоторыми особенностями, предназначенными специально для вычислений общего назначения.

Преимущества CUDA перед традиционным подходом к GPGPU вычислениям

CUDA обеспечивает доступ к разделяемой между потоками памяти размером в 16 Кб на мультипроцессор, которая может быть использована для организации кэша с широкой полосой пропускания, по сравнению с текстурными выборками;

Более эффективная передача данных между системной и видеопамятью;

Отсутствие необходимости в графических API с избыточностью и накладными расходами;

Линейная адресация памяти, и gather и scatter, возможность записи по произвольным адресам;

Аппаратная поддержка целочисленных и битовых операций.

Основные ограничения CUDA:

Отсутствие поддержки рекурсии для выполняемых функций;

Минимальная ширина блока в 32 потока;

Закрытая архитектура CUDA, принадлежащая NVIDIA.

Слабыми местами программирования при помощи предыдущих методов GPGPU является то, что эти методы не используют блоки исполнения вершинных шейдеров в предыдущих неунифицированных архитектурах, данные хранятся в текстурах, а выводятся во внеэкранный буфер, а многопроходные алгоритмы используют пиксельные шейдерные блоки. В ограничения GPGPU можно включить: недостаточно эффективное использование аппаратных возможностей, ограничения полосой пропускания памяти, отсутствие операции scatter (только gather), обязательное использование графического API.

Основные преимущества CUDA по сравнению с предыдущими методами GPGPU вытекают из того, что эта архитектура спроектирована для эффективного использования неграфических вычислений на GPU и использует язык программирования C, не требуя переноса алгоритмов в удобный для концепции графического конвейера вид. CUDA предлагает новый путь вычислений на GPU, не использующий графические API, предлагающий произвольный доступ к памяти (scatter или gather). Такая архитектура лишена недостатков GPGPU и использует все исполнительные блоки, а также расширяет возможности за счёт целочисленной математики и операций битового сдвига.

CUDA открывает некоторые аппаратные возможности, недоступные из графических API, такие как разделяемая память. Это память небольшого объёма (16 килобайт на мультипроцессор), к которой имеют доступ блоки потоков. Она позволяет кэшировать наиболее часто используемые данные и может обеспечить более высокую скорость, по сравнению с использованием текстурных выборок для этой задачи. Что, в свою очередь, снижает чувствительность к пропускной способности параллельных алгоритмов во многих приложениях. Например, это полезно для линейной алгебры, быстрого преобразования Фурье и фильтров обработки изображений.

Удобнее в CUDA и доступ к памяти. Программный код в графических API выводит данные в виде 32-х значений с плавающей точкой одинарной точности (RGBA значения одновременно в восемь render target) в заранее предопределённые области, а CUDA поддерживает scatter запись - неограниченное число записей по любому адресу. Такие преимущества делают возможным выполнение на GPU некоторых алгоритмов, которые невозможно эффективно реализовать при помощи методов GPGPU, основанных на графических API.

Также, графические API в обязательном порядке хранят данные в текстурах, что требует предварительной упаковки больших массивов в текстуры, что усложняет алгоритм и заставляет использовать специальную адресацию. А CUDA позволяет читать данные по любому адресу. Ещё одним преимуществом CUDA является оптимизированный обмен данными между CPU и GPU. А для разработчиков, желающих получить доступ к низкому уровню (например, при написании другого языка программирования), CUDA предлагает возможность низкоуровневого программирования на ассемблере.

Недостатки CUDA

Один из немногочисленных недостатков CUDA - слабая переносимость. Эта архитектура работает только на видеочипах этой компании, да ещё и не на всех, а начиная с серии GeForce 8 и 9 и соответствующих Quadro, ION и Tesla. NVIDIA приводит цифру в 90 миллионов CUDA-совместимых видеочипов.

Альтернативы CUDA

Фреймворк для написания компьютерных программ, связанных с параллельными вычислениями на различных графических и центральных процессорах. В фреймворк OpenCL входят язык программирования, который базируется на стандарте C99, и интерфейс программирования приложений (API). OpenCL обеспечивает параллелизм на уровне инструкций и на уровне данных и является реализацией техники GPGPU. OpenCL является полностью открытым стандартом, его использование не облагается лицензионными отчислениями.

Цель OpenCL состоит в том, чтобы дополнить OpenGL и OpenAL, которые являются открытыми отраслевыми стандартами для трёхмерной компьютерной графики и звука, пользуясь возможностями GPU. OpenCL разрабатывается и поддерживается некоммерческим консорциумом Khronos Group, в который входят много крупных компаний, включая Apple, AMD, Intel, nVidia, Sun Microsystems, Sony Computer Entertainment и другие.

CAL/IL(Compute Abstraction Layer/Intermediate Language)

ATI Stream Technology - это набор аппаратных и программных технологий, которые позволяют использовать графические процессоры AMD, совместно с центральным процессором, для ускорения многих приложений (не только графических).

Областями применения ATI Stream являются приложения, требовательные к вычислительному ресурсу, такие, как финансовый анализ или обработка сейсмических данных. Использование потокового процессора позволило увеличить скорость некоторых финансовых расчётов в 55 раз по сравнению с решением той же задачи силами только центрального процессора.

Технологию ATI Stream в NVIDIA не считают очень сильным конкурентом. CUDA и Stream - это две разные технологии, которые стоят на различных уровнях развития. Программирование для продуктов ATI намного сложнее - их язык скорее напоминает ассемблер. CUDA C, в свою очередь, гораздо более высокоуровневый язык. Писать на нём удобнее и проще. Для крупных компаний-разработчиков это очень важно. Если говорить о производительности, то можно заметить, что её пиковое значение в продуктах ATI выше, чем в решениях NVIDIA. Но опять всё сводится к тому, как эту мощность получить.

DirectX11 (DirectCompute)

Интерфейс программирования приложений, который входит в состав DirectX - набора API от Microsoft, который предназначен для работы на IBM PC-совместимых компьютерах под управлением операционных систем семейства Microsoft Windows. DirectCompute предназначен для выполнения вычислений общего назначения на графических процессорах, являясь реализацией концепции GPGPU. Изначально DirectCompute был опубликован в составе DirectX 11, однако позже стал доступен и для DirectX 10 и DirectX 10.1.

NVDIA CUDA в российской научной среде.

По состоянию на декабрь 2009 г., программная модель CUDA преподается в 269 университетах мира. В России обучающие курсы по CUDA читаются в Московском, Санкт-Петербургском, Казанском, Новосибирском и Пермском государственных университетах, Международном университете природы общества и человека "Дубна", Объединённом институте ядерных исследований, Московском институте электронной техники, Ивановском государственном энергетическом университете, БГТУ им. В. Г. Шухова, МГТУ им. Баумана, РХТУ им. Менделеева, Российском научном центре "Курчатовский институт", Межрегиональном суперкомпьютерном центре РАН, Таганрогском технологическом институте (ТТИ ЮФУ).

Особенности архитектуры AMD/ATI Radeon

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

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

Итак, что же позволяет GPU претендовать на собственный сектор в сфере программ общего назначения? Микроархитектура GPU построена совсем иначе, чем у обычных CPU, и в ней изначально заложены определенные преимущества. Задачи графики предполагают независимую параллельную обработку данных, и GPU изначально мультипоточен. Но эта параллельность ему только в радость. Микроархитектура спроектирована так, чтобы эксплуатировать имеющееся в наличии большое количество нитей, требующих исполнения.

GPU состоит из нескольких десятков (30 для Nvidia GT200, 20 - для Evergreen, 16 - для Fermi) процессорных ядер, которые в терминологии Nvidia называются Streaming Multiprocessor, а в терминологии ATI - SIMD Engine. В рамках данной статьи мы будем называть их минипроцессорами, потому что они исполняют несколько сотен программных нитей и умеют почти все то же, что и обычный CPU, но все-таки не все.

Маркетинговые названия запутывают - в них, для пущей важности, указывают количество функциональных модулей, которые умеют вычитать и умножать: например, 320 векторных «cores» (ядер). Эти ядра больше похожи на зерна. Лучше представлять GPU как некий многоядерный процессор с большим количеством ядер, исполняющих одновременно множество нитей.

Каждый минипроцессор имеет локальную память, размером 16 KБ для GT200, 32 KБ - для Evergreen и 64 KБ - для Fermi (по сути, это программируемый L1 кэш). Она имеет сходное с кэшем первого уровня обычного CPU время доступа и выполняет аналогичные функции наибыстрейшей доставки данных к функциональным модулям. В архитектуре Fermi часть локальной памяти может быть сконфигурирована как обычный кэш. В GPU локальная память служит для быстрого обмена данными между исполняющимися нитями. Одна из обычных схем GPU-программы такова: в начале в локальную память загружаются данные из глобальной памяти GPU. Это просто обычная видеопамять, расположенная (как и системная память) отдельно от «своего» процессора - в случае видео она распаяна несколькими микросхемами на текстолите видеокарты. Далее несколько сотен нитей работают с этими данными в локальной памяти и записывают результат в глобальную память, после чего тот передается в CPU. В обязанность программиста входит написание инструкций загрузки и выгрузки данных из локальной памяти. По сути, это разбиение данных [конкретной задачи] для параллельной обработки. GPU поддерживает также инструкции атомарной записи/чтения в память, но они неэффективны и востребованы обычно на завершающем этапе для «склейки» результатов вычислений всех минипроцессоров.

Локальная память общая для всех исполняющихся в минипроцессоре нитей, поэтому, например, в терминологии Nvidia она даже называется shared, а термином local memory обозначается прямо противоположное, а именно: некая персональная область отдельной нити в глобальной памяти, видимая и доступная только ей. Но кроме локальной памяти в минипроцессоре есть ещё одна область памяти, во всех архитектурах примерно в четыре раза бо́льшая по объему. Она разделена поровну между всеми исполняющимися нитями, это регистры для хранения переменных и промежуточных результатов вычислений. На каждую нить приходится несколько десятков регистров. Точное количество зависит от того, сколько нитей исполняет минипроцессор. Это количество очень важно, так как латентность глобальной памяти очень велика, сотни тактов, и в отсутствие кэшей негде хранить промежуточные результаты вычислений.

И ещё одна важная черта GPU: «мягкая» векторность. Каждый минипроцессор обладает большим количеством вычислительных модулей (8 для GT200, 16 для Radeon и 32 для Fermi), но все они могут выполнять только одну и ту же инструкцию, с одним программным адресом. Операнды же при этом могут быть разные, у разных нитей свои. Например, инструкция сложить содержимое двух регистров : она одновременно выполняется всеми вычислительными устройствами, но регистры берутся разные. Предполагается, что все нити GPU-программы, осуществляя параллельную обработку данных, в целом движутся параллельным курсом по коду программы. Таким образом, все вычислительные модули загружаются равномерно. А если нити из-за ветвлений в программе разошлись в своем пути исполнения кода, то происходит так называемая сериализация. Тогда используются не все вычислительные модули, так как нити подают на исполнение различные инструкции, а блок вычислительных модулей может исполнять, как мы уже сказали, только инструкцию с одним адресом. И, разумеется, производительность при этом падает по отношению к максимальной.

Плюсом является то, что векторизация происходит полностью автоматически, это не программирование с использованием SSE, MMX и так далее. И GPU сам обрабатывает расхождения. Теоретически, можно вообще писать программы для GPU, не думая о векторной природе исполняющих модулей, но скорость такой программы будет не очень высокой. Минус заключается в большой ширине вектора. Она больше, чем номинальное количество функциональных модулей, и составляет 32 для GPU Nvidia и 64 для Radeon. Нити обрабатываются блоками соответствующего размера. Nvidia называет этот блок нитей термином warp, AMD - wave front, что одно и то же. Таким образом, на 16 вычислительных устройствах «волновой фронт» длиной 64 нити обрабатывается за четыре такта (при условии обычной длины инструкции). Автор предпочитает в данном случае термин warp, из-за ассоциации с морским термином warp, обозначающим связанный из скрученных веревок канат. Так и нити «скручиваются» и образуют цельную связку. Впрочем, «wave front» тоже может ассоциироваться с морем: инструкции так же прибывают к исполнительным устройствам, как волны одна за другой накатываются на берег.

Если все нити одинаково продвинулись в выполнении программы (находятся в одном месте) и, таким образом, исполняют одну инструкцию, то все прекрасно, но если нет - происходит замедление. В этом случае нити из одного warp или wave front находятся в различных местах программы, они разбиваются на группы нитей, имеющих одинаковое значение номера инструкции (иначе говоря, указателя инструкций (instruction pointer)). И по-прежнему выполняются в один момент времени только нити одной группы - все выполняют одинаковую инструкцию, но с различными операндами. В итоге warp исполняется во столько раз медленней, на сколько групп он разбит, а количество нитей в группе значения не имеет. Даже если группа состоит всего из одной нити, все равно она будет выполняться столько же времени, сколько полный warp. В железе это реализовано с помощью маскирования определенных нитей, то есть инструкции формально выполняются, но результаты их выполнения никуда не записываются и в дальнейшем не используются.

Хотя в каждый момент времени каждый минипроцессор (Streaming MultiProcessor или SIMD Engine) выполняет инструкции, принадлежащие только одному warp (связке нитей), он имеет несколько десятков активных варпов в исполняемом пуле. Выполнив инструкции одного варпа, минипроцессор исполняет не следующую по очереди инструкцию нитей данного варпа, а инструкции кого-нибудь другого варпа. Тот варп может быть в совершенно другом месте программы, это не будет влиять на скорость, так как только внутри варпа инструкции всех нитей обязаны быть одинаковыми для исполнения с полной скоростью.

В данном случае каждый из 20 SIMD Engine имеет четыре активных wave front, в каждом из которых 64 нити. Каждая нить обозначена короткой линией. Всего: 64×4×20=5120 нитей

Таким образом, учитывая, что каждый warp или wave front состоит из 32-64 нитей, минипроцессор имеет несколько сотен активных нитей, которые исполняются практически одновременно. Ниже мы увидим, какие архитектурные выгоды сулит такое большое количество параллельных нитей, но сначала рассмотрим, какие ограничения есть у составляющих GPU минипроцессоров.

Главное, что в GPU нет стека, где могли бы хранится параметры функций и локальные переменные. Из-за большого количества нитей для стека просто нет места на кристалле. Действительно, так как GPU одновременно выполняет порядка 10000 нитей, при размере стека одной нити в 100 КБ совокупный объем составит 1 ГБ, что равно стандартному объему всей видеопамяти. Тем более нет никакой возможности поместить стек сколько-нибудь существенного размера в самом ядре GPU. Например, если положить 1000 байт стека на нить, то только на один минипроцессор потребуется 1 МБ памяти, что почти в пять раз больше совокупного объема локальной памяти минипроцессора и памяти, отведенной на хранение регистров.

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

В Fermi впервые появилась возможность использовать виртуальные функции, но опять-таки их применение лимитировано отсутствием большого быстрого кэша для каждой нити. На 1536 нитей приходится 48 КБ или 16 КБ L1, то есть виртуальные функции в программе можно использовать относительно редко, иначе для стека также будет использоваться медленная глобальная память, что замедлит исполнение и, скорее всего, не принесет выгод по сравнению с CPU-вариантом.

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

Преимущества архитектуры

Но считает GPU очень быстро. И в этом ему помогает его высокая мультипоточность. Большое количество активных нитей позволяет отчасти скрыть большую латентность расположенной отдельно глобальной видеопамяти, составляющую порядка 500 тактов. Особенно хорошо она нивелируется для кода с высокой плотностью арифметических операций. Таким образом, не требуется дорогостоящая с точки зрения транзисторов иерархия кэшей L1-L2-L3. Вместо неё на кристалле можно разместить множество вычислительных модулей, обеспечив выдающуюся арифметическую производительность. А пока исполняются инструкции одной нити или варпа, остальные сотни нитей спокойно ждут своих данных.

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

Но кроме латентности глобальной памяти, в вычислительном устройстве существует ещё множество латентностей, которые надо скрыть. Это латентность передачи данных внутри кристалла от вычислительных устройств к кэшу первого уровня, то есть локальной памяти GPU, и к регистрам, а также кэшу инструкций. Регистровый файл, как и локальная память, расположены отдельно от функциональных модулей, и скорость доступа к ним составляет примерно полтора десятка тактов. И опять-таки большое количество нитей, активных варпов, позволяет эффективно скрыть эту латентность. Причем общая полоса пропускания (bandwidth) доступа к локальной памяти всего GPU, с учетом количества составляющих его минипроцессоров, значительно больше, чем bandwidth доступа к кэшу первого уровня у современных CPU. GPU может переработать значительно больше данных в единицу времени.

Можно сразу сказать, что если GPU не будет обеспечен большим количеством параллельных нитей, то у него будет почти нулевая производительность, потому что он будет работать с тем же темпом, как будто полностью загружен, а выполнять гораздо меньший объем работы. Например, пусть вместо 10000 нитей останется всего одна: производительность упадет примерно в тысячу раз, ибо не только не все блоки будут загружены, но и скажутся все латентности.

Проблема сокрытия латентностей остра и для современных высокочастотных CPU, для её устранения используются изощренные способы - глубокая конвейеризация, внеочередное исполнение инструкций (out-of-order). Для этого требуются сложные планировщики исполнения инструкций, различные буферы и т. п., что занимает место на кристалле. Это все требуется для наилучшей производительности в однопоточном режиме.

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

GPU изначально был приспособлен для оптимального исполнения шейдерных программ для пикселей треугольников, которые, очевидно, независимы и могут исполняться параллельно. И из этого состояния он эволюционировал путем добавления различных возможностей (локальной памяти и адресуемого доступа к видеопамяти, а также усложнения набора инструкций) в весьма мощное вычислительное устройство, которое все же может быть эффективно применено только для алгоритмов, допускающих высокопараллельную реализацию с использованием ограниченного объема локальной памяти.

Пример

Одна из самых классических задач для GPU - это задача вычисления взаимодействия N тел, создающих гравитационное поле. Но если нам, например, понадобится рассчитать эволюцию системы Земля-Луна-Солнце, то GPU нам плохой помощник: мало объектов. Для каждого объекта надо вычислить взаимодействия со всеми остальными объектами, а их всего два. В случае движения Солнечной системы со всеми планетами и их лунами (примерно пара сотен объектов) GPU все еще не слишком эффективен. Впрочем, и многоядерный процессор из-за высоких накладных расходов на управление потоками тоже не сможет проявить всю свою мощь, будет работать в однопоточном режиме. Но вот если требуется также рассчитать траектории комет и объектов пояса астероидов, то это уже задача для GPU, так как объектов достаточно, чтобы создать необходимое количество параллельных потоков расчета.

GPU также хорошо себя проявит, если необходимо рассчитать столкновение шаровых скоплений из сотен тысяч звезд.

Ещё одна возможность использовать мощность GPU в задаче N тел появляется, когда необходимо рассчитать множество отдельных задач, пусть и с небольшим количеством тел. Например, если требуется рассчитать варианты эволюции одной системы при различных вариантах начальных скоростей. Тогда эффективно использовать GPU удастся без проблем.

Детали микроархитектуры AMD Radeon

Мы рассмотрели базовые принципы организации GPU, они общие для видеоускорителей всех производителей, так как у них изначально была одна целевая задача - шейдерные программы. Тем не менее, производители нашли возможность разойтись в деталях микроархитектурной реализации. Хотя и CPU различных вендоров порой сильно отличаются, даже будучи совместимыми, как, например, Pentium 4 и Athlon или Core. Архитектура Nvidia уже достаточно широко известна, сейчас мы рассмотрим Radeon и выделим основные отличия в подходах этих вендоров.

Видеокарты AMD получили полноценную поддержку вычислений общего назначения начиная с семейства Evergreen, в котором также были впервые реализованы спецификации DirectX 11. Карточки семейства 47xx имеют ряд существенных ограничений, которые будут рассмотрены ниже.

Различия в размере локальной памяти (32 КБ у Radeon против 16 КБ у GT200 и 64 КБ у Fermi) в общем не принципиальны. Как и размер wave front в 64 нити у AMD против 32 нитей в warp у Nvidia. Практически любую GPU-программу можно легко переконфигурировать и настроить на эти параметры. Производительность может измениться на десятки процентов, но в случае с GPU это не так принципиально, ибо GPU-программа обычно работает в десять раз медленней, чем аналог для CPU, или в десять раз быстрее, или вообще не работает.

Более важным является использование AMD технологии VLIW (Very Long Instruction Word). Nvidia использует скалярные простые инструкции, оперирующие со скалярными регистрами. Её ускорители реализуют простой классический RISC. Видеокарточки AMD имеют такое же количество регистров, как GT200, но регистры векторные 128-битные. Каждая VLIW-инструкция оперирует несколькими четырехкомпонентными 32-битными регистрами, что напоминает SSE, но возможности VLIW гораздо шире. Это не SIMD (Single Instruction Multiple Data), как SSE - здесь инструкции для каждой пары операндов могут быть различными и даже зависимыми! Например, пусть компоненты регистра А называются a1, a2, a3, a4; у регистра B - аналогично. Можно вычислить с помощью одной инструкции, которая выполняется за один такт, например, число a1×b1+a2×b2+a3×b3+a4×b4 или двумерный вектор (a1×b1+a2×b2, a3×b3+a4×b4).

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

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

Один векторный регистр может вместо четырех чисел одинарной точности хранить одно число двойной точности. И одна VLIW-инструкция может либо сложить две пары чисел double, либо умножить два числа, либо умножить два числа и сложить с третьим. Таким образом, пиковая производительность в double примерно в пять раз ниже, чем во float. Для старших моделей Radeon она соответствует производительности Nvidia Tesla на новой архитектуре Fermi и гораздо выше, чем производительность в double карточек на архитектуре GT200. В потребительских видеокарточках Geforce на основе Fermi максимальная скорость double-вычислений была уменьшена в четыре раза.

Принципиальная схема работы Radeon. Представлен только один минипроцессор из 20 параллельно работающих

Производители GPU, в отличие от производителей CPU (прежде всего, x86-совместимых), не связаны вопросами совместимости. GPU-программа сначала компилируется в некий промежуточный код, а при запуске программы драйвер компилирует этот код в машинные инструкции, специфичные для конкретной модели. Как было описано выше, производители GPU воспользовались этим, придумав удобные ISA (Instruction Set Architecture) для своих GPU и изменяя их от поколения к поколению. Это в любом случае добавило какие-то проценты производительности из-за отсутствия (за ненадобностью) декодера. Но компания AMD пошла ещё дальше, придумав собственный формат расположения инструкций в машинном коде. Они расположены не последовательно (согласно листингу программы), а по секциям.

Сначала идет секция инструкций условных переходов, которые имеют ссылки на секции непрерывных арифметических инструкций, соответствующие различным ветвям переходов. Они называются VLIW bundles (связки VLIW-инструкций). В этих секциях содержатся только арифметические инструкции с данными из регистров или локальной памяти. Такая организация упрощает управление потоком инструкций и доставку их к исполнительным устройствам. Это тем более полезно, учитывая что VLIW-инструкции имеют сравнительно большой размер. Есть также секции для инструкций обращений к памяти.

GPU обоих производителей (и Nvidia, и AMD) также обладают встроенными инструкциями быстрого вычисления за несколько тактов основных математических функций, квадратного корня, экспоненты, логарифмов, синусов и косинусов для чисел одинарной точности. Для этого есть специальные вычислительные блоки. Они «произошли» от необходимости реализации быстрой аппроксимации этих функций в геометрических шейдерах.

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

Но более явная черта, выдающая графическое происхождение устройства, это блоки чтения двумерных и трехмерных текстур с поддержкой билинейной интерполяции. Они широко используются в GPU-программах, так как обеспечивают ускоренное и упрощенное чтение массивов данных read-only. Одним из стандартных вариантов поведения GPU-приложения является чтение массивов исходных данных, обработка их в вычислительных ядрах и запись результата в другой массив, который передается далее обратно в CPU. Такая схема стандартна и распространена, потому что удобна для архитектуры GPU. Задачи, требующие интенсивно читать и писать в одну большую область глобальной памяти, содержащие, таким образом, зависимости по данным, трудно распараллелить и эффективно реализовать на GPU. Также их производительность будет сильно зависеть от латентности глобальной памяти, которая очень велика. А вот если задача описывается шаблоном «чтение данных - обработка - запись результата», то почти наверняка можно получить большой прирост от ее исполнения на GPU.

Для текстурных данных в GPU существует отдельная иерархия небольших кэшей первого и второго уровней. Она-то и обеспечивает ускорение от использования текстур. Эта иерархия изначально появилась в графических процессорах для того, чтобы воспользоваться локальностью доступа к текстурам: очевидно, после обработки одного пикселя для соседнего пикселя (с высокой вероятностью) потребуются близко расположенные данные текстуры. Но и многие алгоритмы обычных вычислений имеют сходный характер доступа к данным. Так что текстурные кэши из графики будут очень полезны.

Хотя размер кэшей L1-L2 в карточках Nvidia и AMD примерно сходен, что, очевидно, вызвано требованиями оптимальности с точки зрения графики игр, латентность доступа к этим кэшам существенно разнится. Латентность доступа у Nvidia больше, и текстурные кэши в Geforce в первую очередь помогают сократить нагрузку на шину памяти, а не непосредственно ускорить доступ к данным. Это не заметно в графических программах, но важно для программ общего назначения. В Radeon же латентность текстурного кэша ниже, зато выше латентность локальной памяти минипроцессоров. Можно привести такой пример: для оптимального перемножения матриц на карточках Nvidia лучше воспользоваться локальной памятью, загружая туда матрицу поблочно, а для AMD лучше положиться на низколатентный текстурный кэш, читая элементы матрицы по мере надобности. Но это уже достаточно тонкая оптимизация, и для уже принципиально переведенного на GPU алгоритма.

Это различие также проявляется в случае использования 3D-текстур. Один из первых бенчмарков вычислений на GPU, который показывал серьезное преимущество AMD, как раз и использовал 3D-текстуры, так как работал с трехмерным массивом данных. А латентность доступа к текстурам в Radeon существенно быстрее, и 3D-случай дополнительно более оптимизирован в железе.

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

Ограничения серии Radeon 47xx

В этом семействе поддержка вычислений на GPU неполна. Можно отметить три важных момента. Во-первых, нет локальной памяти, то есть она физически есть, но не обладает возможностью универсального доступа, требуемого современным стандартом GPU-программ. Она эмулируется программно в глобальной памяти, то есть её использование в отличие от полнофункционального GPU не принесет выгод. Второй момент - ограниченная поддержка различных инструкций атомарных операций с памятью и инструкций синхронизации. И третий момент - это довольно маленький размер кэша инструкций: начиная с некоторого размера программы происходит замедление скорости в разы. Есть и другие мелкие ограничения. Можно сказать, только идеально подходящие для GPU программы будут хорошо работать на этой видеокарточке. Пусть в простых тестовых программах, которые оперируют только с регистрами, видеокарточка может показывать хороший результат в Gigaflops, что-то сложное эффективно запрограммировать под нее проблематично.

Преимущества и недостатки Evergreen

Если сравнить продукты AMD и Nvidia, то, с точки зрения вычислений на GPU, серия 5xxx выглядит, как очень мощный GT200. Такой мощный, что по пиковой производительности превосходит Fermi примерно в два c половиной раза. Особенно после того, как параметры новых видеокарточек Nvidia были урезаны, сокращено количество ядер. Но появление в Fermi кэша L2 упрощает реализацию на GPU некоторых алгоритмов, таким образом расширяя область применения GPU. Что интересно, для хорошо оптимизированных под прошлое поколение GT200 CUDA-программ архитектурные нововведения Fermi зачастую ничего не дали. Они ускорились пропорционально увеличению количества вычислительных модулей, то есть менее чем в два раза (для чисел одинарной точности), а то и ещё меньше, ибо ПСП памяти не увеличилась (или по другим причинам).

И в хорошо ложащихся на архитектуру GPU задачах, имеющих выраженную векторную природу (например, перемножении матриц), Radeon показывает относительно близкую к теоретическому пику производительность и обгоняет Fermi. Не говоря уже о многоядерных CPU. Особенно в задачах с числами с одинарной точностью.

Но Radeon имеет меньшую площадь кристалла, меньшее тепловыделение, энергопотребление, больший выход годных и, соответственно, меньшую стоимость. И непосредственно в задачах 3D-графики выигрыш Fermi, если он вообще есть, гораздо меньше разницы в площади кристалла. Во многом это объясняется тем, что вычислительная архитектура Radeon с 16 вычислительными устройствами на минипроцессор, размером wave front в 64 нити и векторными VLIW-инструкциями прекрасна для его главной задачи - вычисления графических шейдеров. Для абсолютного большинства обычных пользователей производительность в играх и цена приоритетны.

С точки зрения профессиональных, научных программ, архитектура Radeon обеспечивает лучшее соотношение цена-производительность, производительность на ватт и абсолютную производительность в задачах, которые в принципе хорошо соответствуют архитектуре GPU, допускают параллелизацию и векторизацию.

Например, в полностью параллельной легко векторизуемой задаче подбора ключей Radeon в несколько раз быстрее Geforce и в несколько десятков раз быстрее CPU.

Это соответствует общей концепции AMD Fusion, согласно которой GPU должны дополнять CPU, и в будущем интегрироваться в само ядро CPU, как ранее математический сопроцессор был перенесен с отдельного кристалла в ядро процессора (это случилось лет двадцать назад, перед появлением первых процессоров Pentium). GPU будет интегрированным графическим ядром и векторным сопроцессором для потоковых задач.

В Radeon используется хитрая техника смешения инструкций из различных wave front при исполнении функциональными модулями. Это легко сделать, так как инструкции полностью независимы. Принцип аналогичен конвейерному исполнению независимых инструкций современными CPU. По всей видимости, это дает возможность эффективно исполнять сложные, занимающие много байт, векторные VLIW-инструкции. В CPU для этого требуется сложный планировщик для выявления независимых инструкций или использование технологии Hyper-Threading, которая также снабжает CPU заведомо независимыми инструкциями из различных потоков.

128 инструкций двух wave front, каждый из которых состоит из 64 операций, исполняются 16 VLIW-модулями за восемь тактов. Происходит чередование, и каждый модуль в реальности имеет два такта на исполнение целой инструкции при условии, что он на втором такте начнет выполнять новую параллельно. Вероятно, это помогает быстро исполнить VLIW-инструкцию типа a1×a2+b1×b2+c1×c2+d1×d2, то есть исполнить восемь таких инструкций за восемь тактов. (Формально получается, одну за такт.)

В Nvidia, по-видимому, такой технологии нет. И в отсутствие VLIW, для высокой производительности с использованием скалярных инструкций требуется высокая частота работы, что автоматически повышает тепловыделение и предъявляет высокие требования к технологическому процессу (чтобы заставить работать схему на более высокой частоте).

Недостатком Radeon с точки зрения GPU-вычислений является большая нелюбовь к ветвлениям. GPU вообще не жалуют ветвления из-за вышеописанной технологии выполнения инструкций: сразу группой нитей с одним программным адресом. (Кстати, такая техника называется SIMT: Single Instruction - Multiple Threads (одна инструкция - много нитей), по аналогии с SIMD, где одна инструкция выполняет одну операцию с различными данными.) Однако Radeon ветвления не любят особенно: это вызвано бо́льшим размером связки нитей. Понятно, что если программа не полностью векторная, то чем больше размер warp или wave front, тем хуже, так как при расхождении в пути по программе соседних нитей образуется больше групп, которые необходимо исполнять последовательно (сериализованно). Допустим, все нити разбрелись, тогда в случае размера warp в 32 нити программа будет работать в 32 раза медленней. А в случае размера 64, как в Radeon, - в 64 раза медленней.

Это заметное, но не единственное проявление «неприязни». В видеокарточках Nvidia каждый функциональный модуль, иначе называемый CUDA core, имеет специальный блок обработки ветвлений. А в видеокартах Radeon на 16 вычислительных модулей - всего два блока управления ветвлениями (они выведены из домена арифметических блоков). Так что даже простая обработка инструкции условного перехода, пусть её результат и одинаков для всех нитей в wave front, занимает дополнительное время. И скорость проседает.

Компания AMD производит к тому же и CPU. Они полагают, что для программ с большим количеством ветвлений все равно лучше подходит CPU, а GPU предназначен для чисто векторных программ.

Так что Radeon предоставляет в целом меньше возможностей для эффективного программирования, но обеспечивает лучшее соотношение цена-производительность во многих случаях. Другими словами, программ, которые можно эффективно (с пользой) перевести с CPU на Radeon, меньше, чем программ, эффективно работающих на Fermi. Но зато те, которые эффективно перенести можно, будут работать на Radeon эффективнее во многих смыслах.

API для GPU-вычислений

Сами технические спецификации Radeon смотрятся привлекательно, пусть и не стоит идеализировать и абсолютизировать вычисления на GPU. Но не менее важно для производительности программное обеспечение, необходимое для разработки и выполнения GPU-программы - компиляторы с языка высокого уровня и run-time, то есть драйвер, который осуществляет взаимодействие между частью программы, работающей на CPU, и непосредственно GPU. Оно даже более важно, чем в случае CPU: для CPU не нужен драйвер, который будет осуществлять менеджмент передачи данных, и с точки зрения компилятора GPU более привередлив. Например, компилятор должен обойтись минимальным количеством регистров для хранения промежуточных результатов вычислений, а также аккуратно встраивать вызовы функций, опять-таки используя минимум регистров. Ведь чем меньше регистров использует нить, тем больше нитей можно запустить и тем полнее нагрузить GPU, лучше скрывая время доступа к памяти.

И вот программная поддержка продуктов Radeon пока отстает от развития железа. (В отличие от ситуации с Nvidia, где откладывался выпуск железа, и продукт вышел в урезанном виде.) Ещё совсем недавно OpenCL-компилятор производства AMD имел статус бета, со множеством недоработок. Он слишком часто генерил ошибочный код либо отказывался компилировать код из правильного исходного текста, либо сам выдавал ошибку работы и зависал. Только в конце весны вышел релиз с высокой работоспособностью. Он тоже не лишен ошибок, но их стало значительно меньше, и они, как правило, возникают на боковых направлениях, когда пытаются запрограммировать что-то на грани корректности. Например, работают с типом uchar4, который задает 4-байтовую четырехкомпонентную переменную. Этот тип есть в спецификациях OpenCL, но работать с ним на Radeon не стоит, ибо регистры-то 128-битные: те же четыре компоненты, но 32-битные. А такая переменная uchar4 все равно займет целый регистр, только еще потребуются дополнительные операции упаковки и доступа к отдельным байтовым компонентам. Компилятор не должен иметь никаких ошибок, но компиляторов без недочетов не бывает. Даже Intel Compiler после 11 версий имеет ошибки компиляции. Выявленные ошибки исправлены в следующем релизе, который выйдет ближе к осени.

Но есть ещё множество вещей, требующих доработки. Например, до сих пор стандартный GPU-драйвер для Radeon не имеет поддержки GPU-вычислений с использованием OpenCL. Пользователь должен загружать и устанавливать дополнительный специальный пакет.

Но самое главное - это отсутствие каких бы то ни было библиотек функций. Для вещественных чисел двойной точности нет даже синуса, косинуса и экспоненты. Что ж, для сложения-умножения матриц этого не требуется, но если вы хотите запрограммировать что-то более сложное, надо писать все функции с нуля. Или ждать нового релиза SDK. В скором времени должна выйти ACML (AMD Core Math Library) для GPU-семейства Evergreen с поддержкой основных матричных функций.

На данный момент, по мнению автора статьи, реальным для программирования видеокарт Radeon видится использование API Direct Compute 5.0, естественно учитывая ограничения: ориентацию на платформу Windows 7 и Windows Vista. У Microsoft большой опыт в создании компиляторов, и можно ожидать полностью работоспособный релиз очень скоро, Microsoft напрямую в этом заинтересована. Но Direct Compute ориентирован на нужды интерактивных приложений: что-то посчитать и сразу же визуализировать результат - например, течение жидкости по поверхности. Это не значит, что его нельзя использовать просто для расчетов, но это не его естественное предназначение. Скажем, Microsoft не планирует добавлять в Direct Compute библиотечные функции - как раз те, которых нет на данный момент у AMD. То есть то, что сейчас можно эффективно посчитать на Radeon - некоторые не слишком изощренные программы, - можно реализовать и на Direct Compute, который гораздо проще OpenCL и должен быть стабильнее. Плюс, он полностью портабельный, будет работать и на Nvidia, и на AMD, так что компилировать программу придется только один раз, в то время как реализации OpenCL SDK компаний Nvidia и AMD не совсем совместимы. (В том смысле, что если разработать OpenCL-программу на системе AMD с использованием AMD OpenCL SDK, она может не пойти так просто на Nvidia. Возможно, потребуется компилировать тот же текст с использованием Nvidia SDK. И, разумеется, наоборот.)

Потом, в OpenCL много избыточной функциональности, так как OpenCL задуман как универсальный язык программирования и API для широкого круга систем. И GPU, и CPU, и Cell. Так что на случай, если надо просто написать программу для типичной пользовательской системы (процессор плюс видеокарта), OpenCL не представляется, так сказать, «высокопродуктивным». У каждой функции десять параметров, и девять из них должны быть установлены в 0. А для того, чтобы установить каждый параметр, надо вызывать специальную функцию, у которой тоже есть параметры.

И самый главный текущий плюс Direct Compute - пользователю не надо устанавливать специальный пакет: все, что необходимо, уже есть в DirectX 11.

Проблемы развития GPU-вычислений

Если взять сферу персональных компьютеров, то ситуация такова: существует не так много задач, для которых требуется большая вычислительная мощность и сильно не хватает обычного двухъядерного процессора. Как будто бы из моря на сушу вылезли большие прожорливые, но неповоротливые чудовища, а на суше-то и есть почти нечего. И исконные обители земной поверхности уменьшаются в размерах, учатся меньше потреблять, как всегда бывает при дефиците природных ресурсов. Если бы сейчас была такая же потребность в производительности, как 10-15 лет назад, GPU-вычисления приняли бы на ура. А так проблемы совместимости и относительной сложности GPU-программирования выходят на первый план. Лучше написать программу, которая работала бы на всех системах, чем программу, которая работает быстро, но запускается только на GPU.

Несколько лучше перспективы GPU с точки зрения использования в профессиональных приложениях и секторе рабочих станций, так как там больше потребности в производительности. Появляются плагины для 3D-редакторов с поддержкой GPU: например, для рендеринга с помощью трассировки лучей - не путать с обычным GPU-рендеренгом! Что-то появляется и для 2D-редакторов и редакторов презентаций, с ускорением создания сложных эффектов. Программы обработки видео также постепенно обзаводятся поддержкой GPU. Вышеприведенные задачи в виду своей параллельной сущности хорошо ложатся на архитектуру GPU, но сейчас создана очень большая база кода, отлаженного, оптимизированного под все возможности CPU, так что потребуется время, чтобы появились хорошие GPU-реализации.

В этом сегменте проявляются и такие слабые стороны GPU, как ограниченный объем видеопамяти - примерно в 1 ГБ для обычных GPU. Одним из главных факторов, снижающих производительность GPU-программ, является необходимость обмена данными между CPU и GPU по медленной шине, а из-за ограниченного объема памяти приходится передавать больше данных. И тут перспективной смотрится концепция AMD по совмещению GPU и CPU в одном модуле: можно пожертвовать высокой пропускной способностью графической памяти ради легкого и простого доступа к общей памяти, к тому же с меньшей латентностью. Эта высокая ПСП нынешней видеопамяти DDR5 гораздо больше востребована непосредственно графическими программами, чем большинством программ GPU-вычислений. Вообще, общая память GPU и CPU просто существенно расширит область применения GPU, сделает возможным использование его вычислительных возможностей в небольших подзадачах программ.

И больше всего GPU востребованы в сфере научных вычислений. Уже построено несколько суперкомпьютеров на базе GPU, которые показывают очень высокий результат в тесте матричных операций. Научные задачи так многообразны и многочисленны, что всегда находится множество, которое прекрасно ложится на архитектуру GPU, для которого использование GPU позволяет легко получить высокую производительность.

Если среди всех задач современных компьютеров выбрать одну, то это будет компьютерная графика - изображение мира, в котором мы живем. И оптимальная для этой цели архитектура не может быть плохой. Это настолько важная и фундаментальная задача, что специально разработанное для неё железо должно нести в себе универсальность и быть оптимальным для различных задач. Тем более что видеокарточки успешно эволюционируют.

Одной из наиболее скрытых функций, в недавнем обновлении Windows 10, является возможность проверить, какие приложения используют ваш графический процессор (GPU). Если вы когда-либо открывали диспетчер задач, то наверняка смотрели на использование вашего ЦП, чтобы узнать, какие приложения наиболее грузят ЦП. В последних обновлениях добавлена ​​аналогичная функция, но для графических процессоров GPU. Это помогает понять, насколько интенсивным является ваше программное обеспечение и игры на вашем графическом процессоре, не загружая программное обеспечение сторонних разработчиков. Есть и еще одна интересная функция, которая помогает разгрузить ваш ЦП на GPU. Рекомендую почитать, как выбрать .

Почему у меня нет GPU в диспетчере задач?

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

1. Нажмите "Пуск " и в поиске напишите dxdiag для запуска средства диагностики DirectX.
2. Перейдите во вкладку "Экран", справа в графе "драйверы " у вас должна быть модель WDDM больше 2.0 версии для использования GPU графы в диспетчере задач.

Включить графу GPU в диспетчере задач

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

• Нажмите сочетание кнопок Ctrl + Shift + Esc , чтобы открыть диспетчер задач.
• Нажмите правой кнопкой мыши в диспетчере задач на поле пустое "Имя" и отметьте из выпадающего меню GPU. Вы также можете отметить Ядро графического процессора , чтобы видеть, какие программы используют его.
• Теперь в диспетчере задач, справа видна графа GPU и ядро графического процессора.

Просмотр общей производительности графического процессора

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

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

Ядер много не бывает…

Современные GPU – это монструозные шустрые бестии, способные пережевывать гигабайты данных. Однако человек хитер и, как бы не росли вычислительные мощности, придумывает задачи все сложнее и сложнее, так что приходит момент когда с грустью приходиться констатировать – нужна оптимизацию 🙁

В данной статье описаны основные понятия, для того чтобы было легче ориентироваться в теории gpu-оптимизации и базовые правила, для того чтобы к этим понятиям, приходилось обращаться по-реже.

Причины по которой GPU эффективны для работы с большими объемами данных, требующих обработки:

• у них большие возможности по параллельному исполнению задач (много-много процессоров)
• высокая пропускная способность у памяти

Пропускная способность памяти (memory bandwidth) – это сколько информации – бит или гигабайт – может может быть передано за единицу времени секунду или процессорный такт.

Одна из задач оптимизации – задействовать по максимуму пропускную способность – увеличить показатели throughput (в идеале она должна быть равна memory bandwidth).

Для улучшения использования пропускной способности:

• увеличить объем информации – использовать пропускной канал на полную (например каждый поток работает с флоат4)
• уменьшать латентность – задержку между операциями

Задержка (latency) – промежуток времени между моментами, когда контролер запросил конкретную ячейку памяти и тем моментом, когда данные стали доступны процессору для выполнения инструкций. На саму задержку мы никак повлиять не можем – эти ограничения присутствуют на аппаратном уровне. Именно за счет этой задержки процессор может одновременно обслуживать несколько потоков – пока поток А запросил выделить ему памяти, поток Б может что-то посчитать, а поток С ждать пока к нему придут запрошенные данные.

Как снизить задержку (latency) если используется синхронизация:

• уменьшить число потоков в блоке
• увеличить число групп-блоков

Использование ресурсов GPU на полную – GPU Occupancy

В высоколобых разговорах об оптимизации часто мелькает термин – gpu occupancy или kernel occupancy – он отражает эффективность использования ресурсов-мощностей видеокарты. Отдельно отмечу – если вы даже и используете все ресурсы – это отнюдь не значит что вы используете их правильно.

Вычислительные мощности GPU – это сотни процессоров жадных до вычислений, при создании программы – ядра (kernel) – на плечи программиста ложиться бремя распределения нагрузки на них. Ошибка может привести к тому, что большая часть этих драгоценных ресурсов может бесцельно простаивать. Сейчас я объясню почему. Начать придется издалека.

Напомню, что варп (warp в терминологии NVidia, wavefront – в терминологии AMD) – набор потоков которые одновременно выполняют одну и туже функцию-кернел на процессоре. Потоки, объединенные программистом в блоки разбиваются на варпы планировщиком потоков (отдельно для каждого мультипроцессора) – пока один варп работает, второй ждет обработки запросов к памяти и т.д. Если какие-то из потоков варпа все еще выполняют вычисления, а другие уже сделали все что могли – имеет место быть неэффективное использование вычислительного ресурса – в народе именуемое простаивание мощностей.

Каждая точка синхронизации, каждое ветвление логики может породить такую ситуацию простоя. Максимальная дивергенция (ветвление логики исполнения) зависит от размера варпа. Для GPU от NVidia – это 32, для AMD – 64.

Для того чтобы снизить простой мультипроцессора во время выполнения варпа:

• минимизировать время ожидания барьеров
• минимизировать расхождение логики выполнения в функции-кернеле

Для эффективного решения данной задачи имеет смысл разобраться – как же происходит формирование варпов (для случая с несколькими размерностями). На самом деле порядок простой – в первую очередь по X, потом по Y и, в последнюю очередь, Z.

ядро запускается с блоками размерностью 64×16, потоки разбиваются по варпам в порядке X, Y, Z – т.е. первые 64 элемента разбиваются на два варпа, потом вторые и т.д.

Ядро запускается с блоками размерностью 16×64. В первый варп добавляются первые и вторые 16 элементов, во второй варп – третьи и четвертые и т.д.

Как снижать дивергенцию (помните – ветвление – не всегда причина критичной потери производительности)

• когда у смежных потоков разные пути исполнения – много условий и переходов по ним – искать пути ре-структуризации
• искать не сбалансированную загрузку потоков и решительно ее удалять (это когда у нас мало того что есть условия, дак еще из-за этих условиях первый поток всегда что-то вычисляет, а пятый в это условие не попадает и простаивает)

Как использовать ресурсы GPU по максимуму

Ресурсы GPU, к сожалению, тоже имеют свои ограничения. И, строго говоря, перед запуском функции-кернела имеет смысл определить лимиты и при распределении нагрузки эти лимиты учесть. Почему это важно?

У видеокарт есть ограничения на общее число потоков, которое может выполнять один мультипроцессор, максимальное число потоков в одном блоке, максимальное число варпов на одном процессоре, ограничения на различные виды памяти и т.п. Всю эту информацию можно запросить как программно, через соответствующее API так и предварительно с помощью утилит из SDK. (Модули deviceQuery для устройств NVidia, CLInfo – для видеокарт AMD).

Общая практика:

• число блоков/рабочих групп потоков должно быть кратно количеству потоковых процессоров
• размер блока/рабочей группы должен быть кратен размеру варпа

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

В голове все эти детали держать быстро надоедает, потому для расчет gpu-occupancy NVidia предложила неожиданный инструмент – эксельный(!) калькулятор набитый макросами. Туда можно ввести информацию по максимальному числу потоков для SM, число регистров и размер общей (shared) памяти доступных на потоковом процессоре, и используемые параметры запуска функций – а он выдает в процентах эффективность использования ресурсов (и вы рвете на голове волосы осознавая что чтобы задействовать все ядра вам не хватает регистров).

информация по использованию:
http://docs.nvidia.com/cuda/cuda-c-best-practices-guide/#calculating-occupancy

GPU и операции с памятью

Видеокарты оптимизированы для 128-битных операций с памятью. Т.е. в идеале – каждая манипуляция с памятью, в идеале, должна изменять за раз 4 четырех-байтных значения. Основная неприятность для программиста заключается в том, что современные компиляторы для GPU не умеют оптимизировать такие вещи. Это приходится делать прямо в коде функции и, в среднем, приносит доли-процента по приросту производительности. Гораздо большее влияние на производительность имеет частота запросов к памяти.

Проблема обстоит в следующем – каждый запрос возвращает в ответ кусочек данных размером кратный 128 битам. А каждый поток использует лишь четверть его (в случае обычной четырех-байтовой переменной). Когда смежные потоки одновременно работают с данными расположенными последовательно в ячейках памяти – это снижает общее число обращений к памяти. Называется это явление – объединенные операции чтения и записи (coalesced access – good! both read and write ) – и при верной организации кода (strided access to contiguous chunk of memory – bad! ) может ощутимо улучшить производительность. При организации своего ядра – помните – смежный доступ – в пределах элементов одной строки памяти, работа с элементами столбца – это уже не так эффективно. Хотите больше деталей? мне понравилась вот эта pdf – или гуглите на предмет “memory coalescing techniques “.

Лидирующие позиции в номинации “узкое место” занимает другая операция с памятью – копирование данных из памяти хоста в гпу . Копирование происходит не абы как, а из специально выделенной драйвером и системой области памяти: при запросе на копирование данных – система сначала копирует туда эти данные, а уже потом заливает их в GPU. Скорость транспортировки данных ограничена пропускной способностью шины PCI Express xN (где N число линий передачи данных) через которые современные видеокарты общаются с хостом.

Однако, лишнее копирование медленной памяти на хосте – это порою неоправданные издержки. Выход – использовать так называемую pinned memory – специальным образом помеченную область памяти, так что операционная система не имеет возможности выполнять с ней какие либо операции (например – выгрузить в свап/переместить по своему усмотрению и т.п.). Передача данных с хоста на видеокарту осуществляется без участия операционной системы – асинхронно, через DMA (direct memory access).

И, на последок, еще немного про память. Разделяемая память на мультипроцессоре обычно организована в виде банков памяти содержащих 32 битные слова – данные. Число банков по доброй традиции варьируется от одного поколения GPU к другому – 16/32 Если каждый поток обращается за данными в отдельный банк – все хорошо. Иначе получается несколько запросов на чтение/запись к одному банку и мы получаем – конфликт (shared memory bank conflict ). Такие конфликтные обращения сериализуются и соответственно выполняются последовательно, а не параллельно. Если к одному банку обращаются все потоки – используется “широковещательный” ответ (broadcast ) и конфликта нет. Существует несколько способов эффективно бороться с конфликтами доступа, мне понравилось описание основных методик по избавлению от конфликтов доступа к банкам памяти – .

Как сделать математические операции еще быстрее? Помнить что:

• вычисления двойной точности – это высокая нагрузка операции с fp64 >> fp32
• константы вида 3.13 в коде, по умолчанию, интерпретируется как fp64 если явно не указывать 3.14f
• для оптимизации математики не лишним будет справиться в гайдах – а нет ли каких флажков у компилятора
• производители включают в свои SDK функции, которые используют особенности устройств для достижения производительности (часто – в ущерб переносимости)

Для разработчиков CUDA имеет смысл обратить пристальное внимание на концепцию cuda stream, позволяющих запускать сразу несколько функций-ядер на одному устройстве или совмещать асинхронное копирование данных с хоста на устройство во время выполнения функций. OpenCL, пока, такого функционала не предоставляет 🙁

Утиль для профилирования:

NVifia Visual Profiler – интересная утилитка, анализирует ядра как CUDA так и OpenCL.

P. S. В качестве более пространного руководства по оптимизации, могу порекомендовать гуглить всевозможные best practices guide для OpenCL и CUDA.

• ,

Говоря о параллельных вычислениях на GPU мы должны помнить, в какое время мы живем, сегодняшний день это время когда все в мире ускоренно настолько, что мы с вами теряем счет времени, не замечая, как оно проноситься мимо. Всё, что мы делаем, связано с высокой точностью и скоростью обработки информации, в таких условиях нам непременно нужны инструменты для того, чтобы обработать всю информацию, которая у нас есть и преобразовать её в данные, к тому же говоря о таких задачах надо помнить, что данные задачи необходимы не только крупным организациям или мегакорпорациям, в решение таких задач сейчас нуждаются и рядовые пользователи, которые, которые решают свои жизненные задачи, связанные с высокими технологиями у себя дома на персональных компьютерах! Появление NVIDIA CUDA было не удивительным, а, скорее, обоснованным, потому, как в скором времени будет необходимо обрабатывать значительно более трудоёмкие задачи на ПК, чем ранее. Работа, которая ранее занимала очень много времени, теперь будет занимать считанные минуты, соответственно это повлияет на общую картину всего мира!

Что же такое вычисление на GPU

Вычисления на GPU — это использование GPU для вычисления технических, научных, бытовых задач. Вычисление на GPU заключает в себе использование CPU и GPU с разнородной выборкой между ними, а именно: последовательную часть программ берет на себя CPU , в то время как трудоёмкие вычислительные задачи остаются GPU . Благодаря этому происходит распараллеливание задач, которое приводит к ускорению обработки информации и уменьшает время выполнения работы, система становиться более производительной и может одновременно обрабатывать большее количество задач, чем ранее. Однако, чтобы добиться такого успеха одной лишь аппаратной поддержкой не обойтись, в данном случае необходима поддержка ещё и программного обеспечения, что бы приложение могло переносить наиболее трудоёмкие вычисления на GPU .

Что такое CUDA

CUDA — технология программирования на упрощённом языке Си алгоритмов, которые исполняються на графических процессорах ускорителей GeForce восьмого поколения и старше, а также соответствующих карт Quadro и Tesla от компании NVIDIA. CUDA позволяет включать в текст Си программы специальные функции. Эти функции пишутся на упрощённом языке программирования Си и выполняются на графическом процессоре. Первоначальная версия CUDA SDK была представлена 15 февраля 2007 года. Для успешной трансляции кода на этом языке, в состав CUDA SDK входит собственный Си-компилятор командной строки nvcc компании NVIDIA. Компилятор nvcc создан на основе открытого компилятора Open64 и предназначен для трансляции host-кода (главного, управляющего кода) и device-кода (аппаратного кода) (файлов с расширением .cu ) в объектные файлы, пригодные в процессе сборки конечной программы или библиотеки в любой среде программирования, например в Microsoft Visual Studio.

Возможности технологии

1. Стандартный язык C для параллельной разработки приложений на GPU .
2. Готовые библиотеки численного анализа для быстрого преобразования Фурье и базового пакета программ линейной алгебры.
3. Специальный драйвер CUDA для вычислений с быстрой передачей данных между GPU и CPU .
4. Возможность взаимодействия драйвера CUDA с графическими драйверами OpenGL и DirectX .
5. Поддержка операционных систем Linux 32/64-bit, Windows XP 32/64-bit и MacOS.

Преимущества технологии

1. Интерфейс программирования приложений CUDA (CUDA API) основан на стандартном языке программирования Си с некоторыми ограничениями. Это упрощает и сглаживает процеcс изучения архитектуры CUDA .
2. Разделяемая между потоками память (shared memory) размером в 16 Кб может быть использована под организованный пользователем кэш с более широкой полосой пропускания, чем при выборке из обычных текстур.
3. Более эффективные транзакции между памятью центрального процессора и видеопамятью.
4. Полная аппаратная поддержка целочисленных и побитовых операций.

Пример применения технологии

cRark

Самое трудоёмкое в этой программе — это настойка. Программа имеет консольный интерфейс, но благодаря инструкции, которая прилагается к самой программе, ей можно пользоваться. Далее приведена краткая инструкция по настройке программы. Мы проверим программу на работоспособность и сравним её с другой подобной программой, которая не использует NVIDIA CUDA , в данном случае это известная программа «Advanced Archive Password Recovery».

Из скаченного архива cRark нам нужно только три файла: crark.exe , crark-hp.exe и password.def . Сrark.exe — это консольная утилита вскрытия паролей RAR 3.0 без шифрованных файлов внутри архива (т.е. раскрывая архив мы видим названия, но не можем распаковать архив без пароля).

Сrark-hp.exe — это консольная утилита вскрытия паролей RAR 3.0 с шифрованием всего архива (т.е. раскрывая архив мы не видим ни названия, ни самих архивов и не можем распаковать архив без пароля).

Password.def - это любой переименованный текстовой файл с очень небольшим содержанием (к примеру: 1-я строка: ## 2-я строка: ?* , в этом случае вскрытие пароля будет происходить с использованием всех знаков). Password.def — это руководитель програмы cRark. В файле содержаться правила вскрытия пароля (или область знаков которую crark.exe будет использовать в своей работе). Подробнее о возможностях выбора этих знаков написано в текстовом файле полученном при вскрытии скачанного на сайте у автора программы cRark: russian.def .

Подготовка

Сразу скажу, что программа работает только если ваша видеокарта основана на GPU с поддержкой уровня ускорения CUDA 1.1. Так что серия видеокарт, основанных на чипе G80, таких как GeForce 8800 GTX , отпадает, так как они имеют аппаратную поддержку ускорения CUDA 1.0. Программа подбирает с помощью CUDA только пароли на архивы RAR версий 3.0+. Необходимо установить все программное обеспечение, связанное с CUDA , а именно:

• Драйверы NVIDIA , поддерживающие CUDA , начиная с 169.21
• NVIDIA CUDA SDK , начиная с версии 1.1
• NVIDIA CUDA Toolkit , начиная с версии 1.1

Создаём любую папку в любом месте (например на диске С:) и называем любым именем например «3.2». Помещаем туда файлы: crark.exe , crark-hp.exe и password.def и запароленный/зашифрованный архив RAR.

Далее, следует запустить консоль командной строки Windows и перейти в ней созданную папку. В Windows Vista и 7 следует вызвать меню «Пуск» и в поле поиска ввести «cmd.exe», в Windows XP из меню «Пуск» сначала следует вызвать диалог «Выполнить» и уже в нём вводить «cmd.exe». После открытия консоли следует ввести команду вида: cd C:\папка\ , cd C:\3.2 в данном случае.

Набираем в текстовом редакторе две строки (можно также сохранить текст как файл .bat в папке с cRark) для подбора пароля запароленного RAR-архива с незашифрованными файлами:

echo off;
cmd /K crark (название архива).rar

для подбора пароля запароленного и зашифрованного RAR-архива:

echo off;
cmd /K crark-hp (название архива).rar

Копируем 2 строки текстового файла в консоль и нажимаем Enter (или запускаем.bat файл).

Результаты

Процесс расшифровки показан на рисунке:

Скорость подбора на cRark с помощью CUDA составила 1625 паролей/секунду. За одну минуту тридцать шесть секунд был подобран пароль с 3-мя знаками: «q}$». Для сравнения: скорость перебора в Advanced Archive Password Recovery на моём двуядерном процессоре Athlon 3000+ равна максимум 50 паролей/секунду и перебор должен был бы длиться 5 часов. То есть подбор по bruteforce в cRark архива RAR с помощью видеокарты GeForce 9800 GTX+ происходит в 30 раз быстрее, чем на CPU .

Для тех, у кого процессор Intel, хорошая системная плата с высокой частотой системной шины (FSB 1600 МГц), показатель CPU rate и скорость перебора будут выше. А если у вас четырёхъядерный процессор и пара видеокарт уровня GeForce 280 GTX , то быстродействие перебора паролей ускоряется в разы. Подводя итоги примера надо сказать, что данная задача была решена с применением технологии CUDA всего за каких то 2 минуты вместо 5-ти часов что говорит о высоком потенциале возможностей для данной технологии!

Выводы

Рассмотрев сегодня технологию для параллельных вычислений CUDA мы наглядно увидели всю мощь и огромный потенциал для развития данной технологии на примере программы для восстановления пароля для RAR архивов. Надо сказать о перспективах данной технологии, данная технология непременно найдет место в жизни каждого человека, который решит ей воспользоваться, будь то научные задачи, или задачи, связанные с обработкой видео, или даже экономические задачи которые требуют быстрого точного расчета, всё это приведет к неизбежному повышению производительности труда, которое нельзя будет не заметить. На сегодняшний день в лексикон уже начинает входить словосочетание «домашний суперкомпьютер»; абсолютно очевидно, что для воплощения такого предмета в реальность в каждом доме уже есть инструмент под названием CUDA . Начиная с момента выхода карт, основанных на чипе G80 (2006 г.), выпущено огромное количество ускорителей на базе NVIDIA, поддерживающих технологию CUDA , которая способна воплотить мечты о суперкомпьютерах в каждом доме в реальность. Продвигая технологию CUDA , NVIDIA поднимает свой авторитет в глазах клиентов в виде предоставления дополнительных возможностей их оборудования, которое у многих уже куплено. Остается только лишь верить, что в скором времени CUDA будет развиваться очень быстро и даст пользователям в полной мере воспользоваться всеми возможностями параллельных вычислений на GPU .