Доступ к объектам от ядра

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

Передать данные от узла до вычислить ядра:

• Подготовьте входные данные.

• Укажите, как данные должны быть присвоены единицам работы. Посмотрите Указание, Как Разделить Набор данных.

• Создайте буферный и объект (ы) изображения надлежащего размера. Переместите входные данные от использования памяти хоста gcl_malloc или различное gcl_ copy функции (такой как gcl_memcpy) к устройству. Посмотрите Объекты Памяти в OS X OpenCL для получения дополнительной информации.

• Вызовите ядро. В отличие от этого в стандартном OpenCL, Вы не должны явно устанавливать параметры ядра или ставить в очередь ядро очереди команды OpenCL; вместо этого просто поставьте ядро в очередь как блок очереди отгрузки. Посмотрите Передающие Данные К Ядру.

• Получите результаты. Посмотрите Результаты Получения Ядра.

Указание, как разделить набор данных

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

N-мерный диапазон (cl_ndrange) структура, которую Вы передаете ядру, состоит из следующих полей:

• size_t work_dim:

  Число размерностей для использования для запуска ядра: 1, 2, или 3.

  Некоторые проблемы является самым простым разбить на блоки размера ядра при обработке их как одномерных. Пример этого типа проблемы вычисляет хеш md5 для списка 50 миллионов слов. Вы могли записать ядро, вычисляющее хеш md5 для одного слова, и запустите 50 миллионов экземпляров ядра. В этом случае ndrange является диапазоном 1-D: единственный диапазон (0 - 50 миллионов), который имеет только одну координату. Можно думать о нем как как индекс. В Вашем ядре можно вызвать get_global_id(0), и это даст Вам, что координата — значение от 0 до 49,999,999, который представляет индекс в Ваши данные, которые должен обработать этот экземпляр ядра.

  Если Ваши данные представляют плоское изображение, которое является x пикселями, широкими y пикселями высоко, то у Вас есть двумерный набор данных с каждой точкой данных, представленной ее координатами на осях x и y. Много алгоритмов обработки изображений лучше всего представлены с помощью двумерного ndrange. Скажем, Вы хотите сделать что-то другое к каждому пикселю 2048 x 1 024 изображения. Вы могли записать ядро OpenCL, делающее что-то к единственному пикселю, и затем запускающее его с помощью двумерного ndrange с глобальным размером работы 2048 x 1024. В этом случае Ваше ядро (очевидно), не одномерно. Можно вызвать get_global_id(0) и get_global_id(1) получить x, y координаты этого экземпляра во всем ndrange. Поскольку существует 1 к 1 отображение между ndrange и пикселями, выбирание пикселя для обработки действительно просто; просто вызовите эти две функции.

  Если Вы имеете дело с пространственными данными, включающими (x, y, z) позиция узлов в трехмерном пространстве, можно использовать трехмерный ndrange.

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

• global_work_size:

  global_work_size поле указывает размер каждой размерности. Эффективно, это определяет число общих единиц работы, которые будут запущены. Если у Вас есть одномерный диапазон, и Вы хотите обработать миллион вещей, то global_work_size поле будет {1000000, 0, 0}. При обработке 2 048 пикселей изображением на 1 024 пикселя Вы установили бы work_dim = 2 и global_work_size = { 2048, 1024, 0 }.

  Единственное ограничение на global_work_size это, размер работы каждой размерности должен быть кратным числом local_work_size из той размерности.

• global_work_offset:

  global_work_offset поле указывает смещение на размерность для добавления к значениям, возвращенным get_global_id(…). Скажите, например, у Вас есть список одного миллиона слов, и Вы хотите вычислить md5 хеш Word 50,000 - 60,000. Поскольку данные одномерны, ndrange имел бы a work_dim из 1. Поскольку существует 10 000 элементов, которые будут обработаны, установить global_work_size = {10000, 0, 0}. Для «пропущения» к Word 50,000 с самого начала установите global_work_offset = {50000, 0, 0}. Тем путем, самый первый вызов к get_global_id(0) возвращает 50,000-й пиксель, вторые возвраты 50,001-й пиксель, и т.д.

• local_work_size:

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

  local_work_size дает Вам контроль над размером рабочей группы непосредственно.

Передача данных к ядру

XCode использует Ваш код ядра для автоматической генерации прототипа функции ядра в заголовочном файле ядра. Для передачи данных ядру передайте объекты памяти как параметры (как Вы передали бы параметры любой другой функции) при вызове ядра от кода узла. Параметры ядра OpenCL могут быть ограничены по объему с локальным или глобальным спецификатором, определяя хранение памяти для этих параметров. Это означает, что, с OS X v10.7, параметры ядра объявили с local или __local спецификатор адреса объявляется как size_t в блочном объявлении ядра.

Например, если ядру объявили параметр с local спецификатор адреса:

kernel void foo(

                global float *a,

                local float *shared);  // This kernel parameter is of type

                                       // local float; will be size_t in the

                                       // kernel block

Компилятор генерирует следующее объявление экстерна этого блока ядра:

extern void (^foo_kernel)(

                  const cl_ndrange *ndrange,

                  float *a,

                  size_t shared       // In the generated declaration,

                                      // local float is declared as size_t

             );

Путем соединения буфера возражает с определенными параметрами ядра, Вы позволяете обработать свои данные с помощью функции ядра. Например, в Примере: Выделение, Используя, и Выпуск Буферных Объектов, замечает, как пример кода обрабатывает входной указатель данных очень, как Вы обработали бы указатель в C. В этом примере входные данные являются массивом float значения, и можно обработать каждый элемент float массив путем индексации в указатель.

Получение результатов ядра

Если ядро будет возвращать результаты в буфере, вызовите функцию такой как gcl_memcpy(…) в то время как в блоке на данной очереди.

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

Если ядро будет возвращать результаты в буфере, вызовите dispatch_sync функционируйте как это:

dispatch_sync(queue,

              ^{

                 gcl_memcpy(ptr_c,

                            device_c,

                            num_floats * sizeof(float));

               });

Если ядро будет возвращать результаты в изображении, вызовите dispatch_sync функционируйте как это:

dispatch_sync(queue,^{

                         size_t origin = {0,0,0};

                         size_t region = {512, 512, 1};

                         gcl_copy_image_to_ptr(

                                             results_ptr,

                                             image,

                                             origin,

                                             region);

                       });

Это скопирует байты для 512 x 512 пикселей с изображения на буфер, указанный results_ptr параметр.