Книжная полка Сохранить
Размер шрифта:
А
А
А
|  Шрифт:
Arial
Times
|  Интервал:
Стандартный
Средний
Большой
|  Цвет сайта:
Ц
Ц
Ц
Ц
Ц

Программирование GPU при помощи Python и CUDA

Покупка
Артикул: 748328.01.99
Доступ онлайн
899 ₽
В корзину
Книга предлагает быстрое погружение в программирование GPU. Вы узнаете, как применять закон Амдала, использовать профилировщик для определения узких мест в коде на Python, настроить окружения для программирования GPU. По мере чтения вы будете запускать свой код на GPU и писать полноценные ядра и функции на CUDA С, научитесь отлаживать код при помощи NSight IDE и получите представление об известных библиотеках от NVIDIA, в частности cuFFT и cuBLAS. Вооружившись этими знаниями, вы сможете написать с нуля глубокую нейронную сеть, использующую GPU, и изучить более основательные тем. Книга предназначена для разработчиков и специалистов по обработке данных, которые хотят познакомиться с основами эффективного программирования GPU для улучшения быстродействия, используя программирование на Python. Желательно общее знакомство с базовыми понятиями математики и физики, а также опыт программирования на Python и любом основанном на С языке программирования.
Тоуманен, Б. Программирование GPU при помощи Python и CUDA : практическое пособие / Б. Тоуманен ; пер. с англ. А. В. Борескова. - Москва : ДМК Пресс, 2020. - 254 с. - ISBN 978-5-97060-821-0. - Текст : электронный. - URL: https://znanium.com/catalog/product/1210649 (дата обращения: 29.03.2024). – Режим доступа: по подписке.
Фрагмент текстового слоя документа размещен для индексирующих роботов. Для полноценной работы с документом, пожалуйста, перейдите в ридер.
д-р Бриан Тоуманен

Программирование GPU  
при помощи Python и CUDA

BIRMINGHAM – MUMBAI

Dr. Brian Tuomanen

Hands-On GPU Programming 
with Python and CUDA

Explore high-performance parallel 
computing with CUDA

д-р Бриан Тоуманен

Москва, 2020

Программирование GPU 
при помощи Python и CUDA

Исследуйте высокопроизводительные параллельные 
вычисления с помощью CUDA

УДК 004.438Python
ББК 32.973.22
Т50

Тоуманен Б.
Т50 
Программирование GPU при помощи Python и CUDA / пер. с анг. А. В. Борескова. – М.: ДМК Пресс, 2020. – 254 с.: ил. 

ISBN 978-5-97060-821-0

Книга предлагает быстрое погружение в программирование GPU. Вы узнаете, как 
применять закон Амдала, использовать профилировщик для определения узких мест 
в коде на Python, настроить окружения для программирования GPU. По мере чтения 
вы будете запускать свой код на GPU и писать полноценные ядра и функции на CUDA C, 
научитесь отлаживать код при помощи NSight IDE и получите представление об известных библиотеках от NVIDIA, в частности cuFFT и cuBLAS. Вооружившись этими 
знаниями, вы сможете написать с нуля глубокую нейронную сеть, использующую GPU, 
и изучить более основательные темы.
Книга предназначена для разработчиков и специалистов по обработке данных, 
которые хотят познакомиться с основами эффективного программирования GPU для 
улучшения быстродействия, используя программирование на Python. Желательно 
общее знакомство с базовыми понятиями математики и физики, а также опыт программирования на Python и любом основанном на С языке программирования.

УДК 004.438Python
ББК 32.973.22

Authorized Russian translation of the English edition of Hands-On GPU Programming with 
Python and CUDA ISBN 9781789136678 © 2018 Packt Publishing.
This translation is published and sold by permission of Packt Publishing, which owns or 
controls all rights to publish and sell the same.

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

ISBN 978-1-78899-391-3 (анг.) 
© 2018 Packt Publishing
ISBN 978-5-97060-821-0 (рус.) 
© Оформление, издание, перевод, ДМК Пресс, 2020

Содержание

Об авторе ...........................................................................................................10

О рецензенте ....................................................................................................11

Предисловие ....................................................................................................12

Глава 1. Почему программирование GPU? ...........................................18
Технические требования ......................................................................................19
Параллелизация и закон Амдала .........................................................................19
Использование закона Амдала ........................................................................21
Множество Мандельброта ................................................................................22
Профилировка вашего кода .................................................................................25
Использование модуля cProfile ........................................................................25
Резюме ...................................................................................................................26
Вопросы .................................................................................................................27

Глава 2. Настройка окружения для программирования GPU ......28
Технические требования ......................................................................................29
Убедитесь, что у вас есть требуемое оборудование ...........................................29
Проверка вашего оборудования (Linux) ..........................................................30
Проверка вашего оборудования (Windows) ....................................................31
Установка драйверов для GPU .............................................................................33
Установка драйверов GPU (Linux) ....................................................................33
Установка драйвера GPU (Windows) ................................................................35
Установка окружения для программирования на С++ .......................................35
Настройка GCC, Eclipse IDE и графических зависимостей (Linux) ................35
Установка Visual Studio (Windows) ..................................................................36
Установка CUDA Toolkit ....................................................................................38
Установка окружения Python для программирования GPU ..............................39
Установка PyCUDA (Linux) ................................................................................40
Создание скрипта для настройки окружения (Windows)...............................40
Установка PyCUDA (Windows) ..........................................................................41
Проверка PyCUDA .............................................................................................42
Резюме ...................................................................................................................42
Вопросы .................................................................................................................43

 Содержание

Глава 3. Начало работы с PyCUDA ...........................................................44
Технические требования ......................................................................................44
Опрос вашего GPU ................................................................................................45
Опрос вашего GPU при помощи PyCUDA ........................................................46
Использование класса gpuarray модуля PyCUDA .................................................49
Перенос данных в и из GPU при помощи gpuarray .........................................49
Использование основных поэлементных операций через методы  
gpuarray ...............................................................................................................50
Использование ElementWiseKernel из PyCUDA для выполнения  
поэлементных операций......................................................................................55
Возвращаемся к множеству Мандельброта ....................................................58
Краткая вылазка в функциональное программирование .............................61
Основа параллельного сканирования и редуцирования ...............................63
Резюме ...................................................................................................................64
Вопросы .................................................................................................................65

Глава 4. Ядра, нити, блоки и сетки ...........................................................66
Технические требования ......................................................................................67
Ядра .......................................................................................................................67
Функция SourceModule из PyCUDA ..................................................................67
Нити, блоки и сетки ..............................................................................................70
Игра «Жизнь» Джона Конвея ...........................................................................70
Синхронизация и взаимодействие нитей ..........................................................77
Использование функции устройства __syncthreads() .....................................77
Использование разделяемой памяти ..............................................................80
Алгоритм параллельной префиксной суммы .....................................................82
Алгоритм наивный параллельной префиксной суммы.................................82
Исключающая префиксная сумма и включающая префиксная сумма ........85
Эффективный алгоритм параллельной префиксной суммы ........................85
Эффективный алгоритм параллельной префиксной суммы  
(реализация) .....................................................................................................87
Резюме ...................................................................................................................89
Вопросы .................................................................................................................90

Глава 5. Потоки, события, контексты и одновременность.............91
Технические требования ......................................................................................92
Синхронизация устройства CUDA .......................................................................92
Использование класса stream из PyCUDA .......................................................93
Параллельная игра «Жизнь» Конвея при помощи потоков CUDA ................97
События ...............................................................................................................100
События и потоки ...........................................................................................102
Контексты ............................................................................................................103
Синхронизация в текущем контексте ...........................................................104

Содержание  7

Создание контекста ........................................................................................105
Многопроцессность и многонитиевость на стороне хоста .........................106
Различные контексты для параллельности на стороне хоста .....................107
Резюме .................................................................................................................110
Вопросы ...............................................................................................................111

Глава 6. Отладка и профилирование вашего кода на CUDA ......112
Технические требования ....................................................................................113
Использование printf внутри ядер CUDA .........................................................113
Использование printf для отладки ................................................................115
Заполняем пробелы в CUDA C ............................................................................119
Использование NSight IDE для разработки и отладки кода на CUDA C ..........124
Использование NSight  c Visual Studio IDE под Windows .............................125
Использование NSight с Eclipse под Linux ....................................................128
Использование NSight для понимания варпа в CUDA .................................131
Использование профайлера nvprof и Visual Profiler ........................................134
Резюме .................................................................................................................136
Вопросы ...............................................................................................................136

Глава 7. Использование библиотек CUDA  
вместе со Scikit-CUDA .................................................................................137
Технические требования ....................................................................................138
Установка Scikit-CUDA ........................................................................................139
Базовая линейная алгебра при помощи cuBLAS ..............................................139
Функции 1-го уровня AXPY в cuBLAS ............................................................139
Другие функции cuBLAS 1-го уровня ............................................................141
GEMV 2-го уровня в cuBLAS ...........................................................................142
Функции 3-го уровня GEMM в cuBLAS для измерения  
производительности GPU ..............................................................................144
Быстрое преобразование Фурье при помощи cuFFT .......................................147
Простое одномерное FFT ...............................................................................148
Использование FFT для свертки ....................................................................149
Использование cuFFT для двумерной свертки .............................................150
Использование cuSolver из Scikit-CUDA ............................................................155
Сингулярное разложение (SVD) .....................................................................155
Использование SVD для анализа методом главных компонент (PCA) .......156
Резюме .................................................................................................................158
Вопросы ...............................................................................................................158

Глава 8. Библиотеки функций для GPU CUDA и Thrust .................159
Технические требования ....................................................................................160
Библиотека функций GPU cuRAND ....................................................................160

 Содержание

Оценка π при помощи метода Монте-Карло ................................................161
CUDA Math API ....................................................................................................165
Краткий обзор определенных интегралов ...................................................165
Вычисление определенного интеграла при помощи метода  
Монте-Карло ...................................................................................................166
Пишем тесты ...................................................................................................172
Библиотека CUDA Thrust ....................................................................................174
Использование функторов в Thrust ..............................................................176
Резюме .................................................................................................................178
Вопросы ...............................................................................................................178

Глава 9. Реализация глубокой нейросети ...........................................180

Технические требования ....................................................................................181
Искусственные нейроны и нейросети ..............................................................181
Реализация плотного слоя искусственных нейронов ..................................182
Реализация слоя мягкого максимума ...............................................................187
Реализация функции потери перекрестной энтропии ....................................189
Реализация последовательной сети ..................................................................189
Реализация методов вывода ..........................................................................191
Градиентный спуск .........................................................................................193
Подготовка и нормализация данных ............................................................197
Данные Iris ..........................................................................................................197
Резюме .................................................................................................................200
Вопросы ...............................................................................................................200

Глава 10. Работа с компилированным кодом для GPU ................201

Запуск откомпилированного кода при помощи Ctypes ...................................202
Снова возвращаемся к вычислению множества Мандельброта .................202
Компиляция и запуск PTX-кода .........................................................................208
Написание «оберток» для CUDA Driver API .......................................................209
Использование CUDA Driver API ....................................................................213
Резюме .................................................................................................................216
Вопросы ...............................................................................................................217

Глава 11. Оптимизация быстродействия в CUDA ............................218

Динамический параллелизм .............................................................................219
Быстрая сортировка при помощи динамического параллелизма ..............220
Векторные типы данных и доступ к памяти.....................................................222
Потокобезопасные атомарные операции .........................................................224
Перестановки в пределах варпа ........................................................................225
Вставка PTX-ассемблера прямо в код ................................................................228

Содержание  9

Оптимизированная по быстродействию версия суммирования элементов 
массива ................................................................................................................232
Резюме .................................................................................................................235
Вопросы ...............................................................................................................235

Глава 12. Куда идти далее? ......................................................................237
Расширение знаний о CUDA и программировании GPGPU .............................238
Системы из нескольких GPU ..........................................................................238
Кластерные вычисления и MPI ......................................................................238
OpenCL PyOpenCL ...........................................................................................239
Графика ...............................................................................................................239
OpenGL ............................................................................................................240
DirectX12 .........................................................................................................240
Vulkan ..............................................................................................................240
Машинное обучение и компьютерное зрение .................................................241
Основы ............................................................................................................241
cuDNN ..............................................................................................................241
Tensorflow и Keras ...........................................................................................242
Chainer .............................................................................................................242
OpenCV ............................................................................................................242
Технология блокчейн ..........................................................................................242
Резюме .................................................................................................................243
Вопросы ...............................................................................................................243

Ответы на вопросы ......................................................................................244

Предметный указатель ..............................................................................250

Об авторе

Доктор Бриан Тоуманен работал с CUDA и программированием GPU с 2014 г. 
Он получил степень бакалавра по специальности «Электроинженерия» в университете Вашингтона в Сиэтле, затем некоторое время являлся разработчиком программного обеспечения, после чего продолжил обучение в области математики. В университете Миссури (Колумбия) Бриан защитил кандидатскую 
диссертацию по математике, где впервые столкнулся с программированием 
GPU для решения научных задач. Доктор Тоуманен был приглашен в исследовательскую лабораторию министерства армии США по программированию 
GPU для выяснения вопросов общего назначения и не так давно руководил интеграцией GPU и разработкой стартапа в Мэриленде. Сейчас он работает в качестве специалиста по машинному обучению (Azure CSI) в компании Microsoft 
в Сиэтле.

Я бы хотел поблагодарить профессора Мишеллу Беччи из отдела NCSU ECE и ее 
студента Эндрю Тодда за помощь, оказанную мне как начинающему программисту GPU в 2014 г. Также хочу выразить особую признательность моему редактору 
в Packt Акшаде Иер за содействие в написании данного труда и, наконец, профессору Андреасу Клекнеру за составление великолепной библиотеки PyCUDA, которую я активно использовал в своей книге.

О рецензенте

Вандане Шах была присуждена степень бакалавра по специальности «Электроэнергетика и электротехника» в 2001 г. Она также приобрела навыки MBA 
«Управление персоналом» и магистерскую степень по электронике со специализацией в области разработки VLSI. Также ею была представлена работа на 
получение кандидатской степени по специальности «Электроника», в частности в области обработки изображений и глубокого обучения для диагностики 
опухоли мозга. Областями интересов Ванданы являются обработка изображений, а также встраиваемые системы. Имеет более 13 лет опыта в исследованиях, а также в обучении и подготовке студентов по дисциплине «Электроника 
и связь». Ею было опубликовано множество работ в уважающих себя журналах, 
таких как IEEE, Springer и Interscience. Она также получила государственный 
грант для проведения исследований в области обработки изображений в MRI. 
Кроме того что Вандана прекрасно разбирается в вопросах техники, она неплохо владеет искусством индийского танца катхак.

Я благодарю членов моей семьи за их поддержку во всем.

Предисловие

Приветствую вас и поздравляю! Эта книга является вводным курсом по программированию GPU с использованием Python и CUDA. GPU обычно обозначает Graphics Programming Unit (Графический процессор), но здесь пойдет речь 
не о программировании графики – она является введением в программирование общего вида на GPU или программирование GPGPU (General Purpose GPU). 
За последнее десятилетие стало очевидным, что GPU хорошо подходят для вычислений не только графических изображений, но параллельно с этим для тех, 
которые одновременно требуют высокой пропускной способности. Для этого 
NVIDIA выпустила CUDA Toolkit, благодаря чему область программирования 
GPGPU стала более доступной практически для любого человека, хоть немного 
знакомого с  некоторыми знаниями языка программирования.
Целью книги «Программирование GPU при помощи Python и CUDA» является огромное желание как можно быстрее ввести читателя в мир технологий 
GPGPU. Я старался подать материал так, чтобы в каждой главе можно было 
встретить не только интересные примеры и упражнения, но и прочесть о некоторых веселых случаях. В частности, вы можете набирать приведенные упражнения и выполнять их в вашей любимой среде Python (могут подойти Spyder, 
Jupiter и PyCharm). Таким образом, вы с легкостью запомните все необходимые 
функции и команды и одновременно получите некоторый опыт, как при помощи интуиции могут быть написаны программы для GPGPU.
Поначалу параллельное программирование для GPGPU кажется довольно 
сложным и несколько обескураживающим, особенно если ранее вы соприкасались только с программированием CPU. Вам придется выучить так много 
новых понятий и соглашений, что иногда будет казаться, словно вы видите это 
в первый раз. В такие моменты лучше не отчаиваться, а верить, что все приложенные усилия по освоению данной области не напрасны. Обещаю, что при 
некоторой любознательности и соблюдении дисциплины столь загадочная область, по мере того как вы дойдете до конца книги, станет как бы вашей второй 
сущностью.

Для кого эта книга

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

О чем рассказывает эта книга?  13

большинство книг, казалось, представляло собой сплошной парад аппаратных 
схем и непонятных слов на каждой странице, в то время как само программирование оставалось где-то на заднем плане.
Также моя книга адресована тем, кто на самом деле мечтает по-серьезному 
заняться программированием GPU, но без влезания в многочисленные технические детали и схемы аппаратуры. Мы будем программировать GPU на  
С/С++ (CUDA C), но при этом использовать Python при помощи модуля PyCUDA. 
PyCUDA позволяет писать лишь действительно необходимый низкоуровневый 
код для GPU, причем данный модуль призван самостоятельно отвечать за всю 
необходимую компиляцию, линковку и запуск кода на GPU для нас.

о чем рассказывает эта книга?

Глава 1 «Почему программирование GPU?» объясняет, для чего нам необходимо 
разбираться в данных вопросах и как правильно применить закон Амдала для 
оценки потенциального выигрыша в быстродействии от перевода последовательной программы на GPU.
Глава 2 «Настройка окружения для программирования GPU» объясняет, как 
настроить соответствующее окружение для Python и C++ для использования 
CUDA под Windows и Linux.
Глава 3 «Начало работы с PyCUDA» описывает технические навыки, которые 
вам понадобятся для программирования GPU при помощи Python. В частности, мы увидим, как копировать данные в и из GPU при помощи класса gpuarray и компилировать простейшие ядра при помощи функции PyCUDA ElementwiseKernel.
Глава 4 «Ядра, нити, блоки и сетки» обучит основам написания эффективных 
ядер CUDA, которые являются параллельными функциями, выполняемыми на 
GPU. Мы увидим, как писать выполняемые на GPU функции («последовательные» функции, вызываемые непосредственно ядрами CUDA), и познакомимся 
со структурой сетка/блок CUDA и ее ролью в запуске ядер.
Глава 5 «Потоки, события, контексты и одновременность» покрывает такие 
понятия, как «потоки CUDA», которые позволяют одновременно запускать 
и синхронизировать на GPU множество ядер. Мы увидим, как использовать события CUDA для замера времени выполнения ядер и как создавать и использовать контексты CUDA.
Глава 6 «Отладка и профилирование вашего кода на CUDA» заполнит некоторые пробелы в области чистого CUDA C программирования и покажет, как 
использовать NVIDIA NSight IDE для отладки и разработки, а также как использовать средства профилирования от NVIDIA.
Глава 7 «Использование библиотек CUDA вместе со Scikit­CUDA» дает краткий 
обзор некоторых важных библиотек CUDA при помощи модуля Scikit-CUDA, 
включая cuBLAS, cuFFT и cuSOLVER.

 Предисловие

Глава 8 «Библиотеки функций для GPU CUDA и Thrust» покажет, как использовать cuRAND и функции математического API CUDA в вашем коде, а также как 
использовать контейнеры CUDA Thrust в коде на С++.
Глава 9 «Реализация глубокой нейросети» служит основой, на которой мы построим с самого начала глубокую нейросеть, применяя многие из идей, которые разбирались в книге.
Глава 10 «Работа с компилированным кодом для GPU» покажет, как связывать 
наш код на Python с заранее откомпилированным кодом для GPU при помощи 
PyCUDA и Ctypes.
Глава 11 «Оптимизация быстродействия в CUDA» научит ряду низкоуровневых приемов для CUDA, таких как перестановка в пределах варпа (warp shuffling), векторизованный доступ к памяти, использование PTX и атомарные 
операции.
Глава 12 «Куда идти далее?» является обзором некоторых направлений, которые помогут вам развить ваши навыки программирования GPU.

как получить максимум от этой книги

Это уже техническая тема. Будут сделаны лишь некоторые предположения относительно уровня программирования читателя. Мы будем считать, что:
 
 у вас средний уровень программирования на Python;
 
 вы знакомы со стандартными научными пакетами для Python, такими 
как NumPy, SciPy и Matplotlib;
 
 вы обладаете средним уровнем в любом С-подобном языке (С, С++, Java, 
Rust, Go и т. п.);
 
 вы понимаете динамическое выделение памяти в С (в частности, как использовать функции malloc и free).
Программирование GPU применимо в различных научных областях, где 
чаще всего требуются знания математики, поэтому при приведении множества (если не большинства) примеров будут использоваться ее основы. Я предполагаю, что читатель знаком с программой первого или второго курса высшей 
математики, включая:
 
 тригонометрию (такие функции, как sin, cos, tg…);
 
 вычисления (интегралы, производные, градиенты);
 
 статистику (равномерное и нормальное распределение);
 
 линейную алгебру (векторы, матрицы, векторные пространства, размерность).

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

Также хочется сделать еще одно предположение. Если вы помните, в начале 
книги я говорил, что мы будем работать только с CUDA, которая является про
Используемые соглашения  15

приетарным языком программирования для оборудования NVIDIA. Так что 
для начала вам необходимо наличие соответствующего оборудования. Поэтому я считаю, что у читателя есть доступ к:
 
 64-битовому компьютеру на базе процессора от Intel/AMD;
 
 не менее 4 Гб оперативной памяти;
 
 GPU NVIDIA GTX 1050 или более усовершенствованная.
Читателю также следует знать, что многие прежние версии GPU, скорее всего, будут пригодны для большинства, если не для всех, примеров, приведенных 
в книге, но тем не менее все они были проверены на GTX 1050 под Windows 10 
и GTX 1070 под Linux. Конкретные инструкции по настройке и конфигурации 
приводятся в главе 2 «Настройка окружения для программирования GPU».

используемые соглашения

На протяжении всей книги будут использоваться следующие соглашения.
CodeInText обозначает текст программы, имена таблиц баз данных, имена каталогов, файлов, расширения файлов, пути, URL, ввод пользователя и т. п. Например: «Теперь мы можем использовать функцию cublasSaxpy». 
Блок кода выглядит следующим образом:

cublas.cublasDestroy(handle)
print 'cuBLAS returned the correct value: %s' % np.allclose(np.dot(A,x),
y_gpu.get())

Когда мне хочется привлечь ваше внимание к определенному участку кода, 
я соответствующие строки выделяю жирным шрифтом:

def compute_gflops(precision='S'):

if precision=='S':
    float_type = 'float32'
elif precision=='D':
    float_type = 'float64'
else:
    return -1

Любые команды показываются следующим образом:

$ run cublas_gemm_flops.py

Полужирное выделение обозначает новое понятие, важное слово или слова, 
которые вы видите на экране. Например, слова в меню или диалоговых окнах 
показываются таким образом.

 Предупреждения или важные замечания показываются таким образом.

 Подсказки или приемы показываются таким образом.

Доступ онлайн
899 ₽
В корзину