GPGPU Java Программирование

Прежде чем мы углубимся в кодирование некоторого фона. Существует два конкурирующих пакета GPGPU: OpenCL и CUDA . OpenCL — это открытый стандарт, поддерживаемый всеми поставщиками графических процессоров (а именно AMD, NVIDIA и Intel), в то время как CUDA относится к NVIDIA и будет работать только на картах NVIDIA. Оба SDK поддерживают код C / C ++, что, конечно же, оставляет нас Java-разработчиками на холоде. До сих пор нет чистой поддержки OpenCL или CUDA в Java. Это не сильно поможет программисту на Java, которому нужно использовать огромный потенциал параллелизма графического процессора, если она не возится с интерфейсом Java Native. Конечно, есть некоторые инструменты Java, которые облегчают боль программирования Java GPGPU.

Два самых популярных (IMHO) — это jocl и jcuda . С этими инструментами вам все равно придется писать код на C / C ++, но, по крайней мере, это будет только для кода, который будет выполняться в GPU, что значительно минимизирует усилия.

На этот раз я посмотрю на jcuda и посмотрю, как мы можем написать простую программу GPGPU.

Давайте начнем с настройки среды разработки Linux CUDA GPGPU (хотя среды Windows и Mac также не должны быть сложными в настройке):

Шаг 1 : Установите графический процессор с поддержкой NVIDIA CUDA на свой компьютер. На сайте разработчиков NVIDIA есть список графических процессоров с поддержкой CUDA. Новые графические процессоры NVIDIA почти наверняка поддерживают CUDA, но на всякий случай проверьте спецификацию карты, чтобы убедиться…

Шаг 2 : Установите драйвер NVIDIA и CUDA SDK. Скачайте их и найдите инструкции по установке здесь .

Шаг 3 : Перейдите в каталог ~ / NVIDIA_GPU_Computing_SDK / C / src / deviceQuery и запустите make .

Шаг 4 : Если компиляция прошла успешно, перейдите в каталог ~ / NVIDIA_GPU_Computing_SDK / C / bin / linux / release и запустите файл deviceQuery . Вы получите много технической информации о вашей карте.

Вот что я получил для своей карты GeForce GT 430:

Обратите внимание на 2 мультипроцессора с 48 ядрами CUDA на 96 ядер, что неплохо для недорогой видеокарты стоимостью около 40 евро !!!!

Шаг 5 : Теперь, когда у вас есть среда CUDA, давайте напишем и скомпилируем программу CUDA на C. Напишите следующий код и сохраните его как multiply.cu

Скомпилируйте его с помощью компилятора cuda и запустите:

Итак, что делает приведенный выше код? Функция умножения с квалификатором __global__ называется ядром и представляет собой фактический код, который будет выполняться в графическом процессоре. Код в главной функции выполняется в CPU как обычный код на C, хотя есть некоторые семантические различия:

1. Функция умножения вызывается в скобках <<< 1,1 >>>. Два числа в скобках указывают CUDA, сколько раз код должен быть выполнен. CUDA позволяет нам создавать так называемые одно-, двух- или даже трехмерные потоковые блоки. Числа в этом примере указывают на один блок потока, работающий в одном измерении, таким образом, наш код будет выполнен 1 × 1 = 1 раз.
2. Функции cudaMalloc, cudaMemcpy и cudaFree используются для обработки памяти графического процессора аналогично тому, как мы обрабатываем обычную память компьютера в C. Функция cudaMemcpy важна, поскольку у GPU есть собственная RAM, и прежде чем мы сможем обрабатывать любые данные в ядре нам нужно загрузить их в память GPU. Конечно, мы также должны скопировать результаты обратно в обычную память, когда закончите.

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

Загрузите двоичные файлы jcuda, разархивируйте их и убедитесь, что каталог, содержащий файлы .so (или .dll для Windows), указан либо в параметре java.library.path JVM, либо добавлен в переменную среды LD_LIBRARY_PATH (или ваша переменная PATH в windows). Точно так же файл jcuda-xxxxxxx.jar должен находиться в вашем classpath во время компиляции и выполнения вашей Java-программы.

Итак, теперь, когда у нас есть настройка jcuda, давайте посмотрим на наше jcuda-совместимое ядро:

Вы заметите следующие отличия от предыдущего метода ядра:

1. Мы используем квалификатор extern «C», чтобы сказать компилятору не смешивать имя метода умножения, чтобы мы могли вызывать его с его исходным именем.
2. Мы используем массивы вместо примитивов для a, b и c. Это требуется jcuda, поскольку примитивы Java не поддерживаются jcuda. В jcuda данные передаются назад и вперед в GPU в виде массивов, таких как числа с плавающей запятой, целые числа и т. Д.

Сохраните этот файл как multiply2.cu . На этот раз мы не хотим компилировать файл как исполняемый файл, а скорее как библиотеку CUDA, которая будет вызываться в нашей java-программе. Мы можем скомпилировать наше ядро ​​в виде файла PTX или файла CUBIN. PTX — это удобочитаемые файлы, содержащие код, подобный сборке, который будет скомпилирован на лету. Файлы CUBIN являются скомпилированными CUda BINaries и могут вызываться напрямую, без компиляции на лету. Если вам не нужна оптимальная производительность при запуске, файлы PTX предпочтительнее, поскольку они не привязаны к конкретной вычислительной способности графического процессора, с которым они были скомпилированы, в то время как файлы CUBIN не будут работать на графических процессорах с меньшей вычислительной способностью.

Чтобы скомпилировать наше ядро, наберите следующее:

Успешно создав наш файл PTX, давайте посмотрим на Java-эквивалент основного метода, который мы использовали в нашем примере C:

Хорошо, это похоже на большой код для простого умножения двух чисел, но помните, что существуют ограничения относительно указателей Java и C. Итак, начиная со строк с 9 по 11, мы преобразуем наши параметры a, b и c в массивы с именами a, b и c, каждый из которых содержит только одно число с плавающей точкой.

В строках с 13 по 17 мы сообщаем jcuda, что будем использовать первый графический процессор в нашей системе (в высокопроизводительных системах можно использовать более одного графического процессора).

В строках с 19 по 22 мы сообщаем jcuda, где находится наш PTX-файл, и имя метода ядра, который мы хотели бы использовать (в нашем случае умножение .)

Вещи становятся интересными в строке 24, где мы используем специальный класс jcuda CUdeviceptr, который действует как заполнитель указателя. В строке 25 мы используем указатель CUdeviceptr, который мы только что создали для выделения памяти GPU. Обратите внимание, что если бы в нашем массиве было более одного элемента, нам нужно было бы умножить константу Sizeof.FLOAT на количество элементов в нашем массиве. Наконец, в строке 26 мы копируем содержимое нашего первого массива в графический процессор. Точно так же мы создаем наш указатель и копируем содержимое в ОЗУ графического процессора для нашего второго массива (b). Для нашего выходного массива (c) нам нужно только выделить память GPU.

В строке 35 мы создаем объект Pointer, который будет содержать все параметры, которые мы хотим передать нашему методу умножения .

Мы выполняем наш код ядра в строке 41, где мы выполняем служебный метод cuKernelLaunch, передавая классы функций и указателей в качестве параметров. Первые шесть параметров после параметра функции определяют количество сеток (сетка — это группа блоков) и блоков, которые в нашем примере равны 1, так как мы будем выполнять ядро ​​только один раз. Следующие два параметра — 0 и ноль и используются для идентификации любой разделяемой памяти (памяти, которая может быть разделена между потоками), которую мы, возможно, определили, в нашем случае ни одного. Следующий параметр содержит созданный нами объект Pointer, содержащий указатели на устройства a, b, c, а последний параметр предназначен для дополнительных опций.

После возвращения нашего ядра мы просто копируем содержимое dev_c в наш массив c, освобождаем всю память, выделенную в GPU, и печатаем результат, сохраненный в c [0], что, конечно, так же, как в нашем примере на C.

Вот как мы компилируем и выполняем программу MultiplyJ.java (при условии, что multiply2.ptx находится в том же каталоге):

Обратите внимание, что в этом примере каталог ~ / GPGPU / jcuda / JCuda-All-0.4.0-beta1-bin-linux-x86_64 уже находится в моем LD_LIBRARY_PATH, поэтому мне не нужно устанавливать параметр java.library.path в JVM.

Надеюсь, к настоящему моменту механика jcuda ясна, хотя мы на самом деле не затрагивали истинную силу GPU — массовый параллелизм. В следующей статье я приведу пример того, как запускать параллельные потоки в CUDA с использованием Java, а также пример того, что НЕ нужно запускать в графическом процессоре. Обработка на GPU имеет смысл для очень специализированных задач, и большинство задач лучше оставить для обработки нашим старым и доверенным процессором.

Справка: GPGPU Java Programming от нашего партнера W4G Спироса Сакеллариу .

Статьи по Теме :

• CPU против GPGPU
• Альтернативы синтаксиса Java лямбда
• Как JVM обрабатывает замки
• Java Fork / Join для параллельного программирования
• Серия Java Best Practices
• Как получить C как производительность в Java