OpenCL

Не путать с OpenGL .

Информацию о криптографической библиотеке, первоначально известной как OpenCL, см. в разделе Botan (библиотека программирования) .

API OpenCL

Оригинальный автор(ы)	Apple Инк.
Разработчики)	Хронос Групп
Начальная версия	28 августа 2009 г ( 28 августа 2009 )
Стабильная версия	3.0.16  / 5 апреля 2024 г ( 5 апреля 2024 г. )
Написано в	C с C++ привязками
Операционная система	Android (зависит от поставщика), FreeBSD , Linux , macOS (через Pocl), Windows
Платформа	ARMv7 , ARMv8 , Ячейка , IA-32 , Мощность , x86-64
Тип	гетерогенных вычислений API
Лицензия	Лицензия спецификации OpenCL
Веб-сайт	www .chronos .org /opencl /

OpenCL C/C++ и C++ для OpenCL

Парадигма	Императивное ( процедурное ), структурированное (только C++), объектно-ориентированное , универсальное программирование.
Семья	С
Стабильная версия	OpenCL C++ 1.0, версия V2.2–11 OpenCL C 3.0 версия V3.0.11 C++ для OpenCL 1.0 и 2021 г. / 20 декабря 2021 г ( 20.12.2021 )
Дисциплина набора текста	Статический , слабый , явный , номинальный
Язык реализации	Специфическая реализация
Расширения имен файлов	.cl .clcpp
Веб-сайт	www .chronos .org /opencl
Основные реализации
AMD, Gallium Compute, IBM, Intel NEO, Intel SDK, Texas Instruments, Nvidia, POCL, Arm
Под влиянием
C99 , CUDA , С++14 , С++17

OpenCL ( открытый язык вычислений ) — это среда для написания программ, которые выполняются на гетерогенных платформах, состоящих из центральных процессоров (ЦП), графических процессоров (ГП), процессоров цифровых сигналов (ЦСП), программируемых вентильных матриц (ПЛИС) и других процессоры или аппаратные ускорители . OpenCL определяет языки программирования (на основе C99 , C++14 и C++17 ) для программирования этих устройств и интерфейсы прикладного программирования (API) для управления платформой и выполнения программ на вычислительных устройствах . OpenCL предоставляет стандартный интерфейс для параллельных вычислений с использованием параллелизма на основе задач и данных .

OpenCL — это открытый стандарт, поддерживаемый некоммерческим технологическим консорциумом Khronos Group . Соответствующие реализации доступны от Altera , AMD , ARM , Creative , IBM , Imagination , Intel , Nvidia , Qualcomm , Samsung , Vivante , Xilinx и ZiiLABS .

Обзор

OpenCL рассматривает вычислительную систему как состоящую из ряда вычислительных устройств , которые могут быть центральными процессорами (ЦП) или «ускорителями», такими как графические процессоры (ГП), подключенными к главному процессору (ЦП). Он определяет C-подобный язык для написания программ. Функции, выполняемые на устройстве OpenCL, называются « ядрами ». Одно вычислительное устройство обычно состоит из нескольких вычислительных блоков , которые, в свою очередь, содержат несколько процессорных элементов (PE). Одно выполнение ядра может выполняться на всех или многих PE параллельно. То, как вычислительное устройство подразделяется на вычислительные блоки и PE, зависит от поставщика; вычислительный блок можно рассматривать как « ядро », но понятие ядра сложно определить для всех типов устройств, поддерживаемых OpenCL (или даже в категории «ЦП»), и количество вычислительных блоков может не соответствовать количеству ядер, заявленному в маркетинговой литературе поставщиков (которое на самом деле может учитываться при подсчете линий SIMD ).

В дополнение к языку программирования, подобному C, OpenCL определяет интерфейс прикладного программирования (API), который позволяет программам, работающим на хосте, запускать ядра на вычислительных устройствах и управлять памятью устройства, которая (по крайней мере, концептуально) отделена от памяти хоста. Программы на языке OpenCL предназначены для компиляции во время выполнения , поэтому приложения, использующие OpenCL, можно переносить между реализациями для различных хост-устройств. Стандарт OpenCL определяет API-интерфейсы хоста для C и C++ ; сторонние API существуют для других языков программирования и платформ, таких как Python , Ява , Перл , Д и .NET . Реализация , стандарта OpenCL состоит из библиотеки реализующей API для C и C++, и компилятора C OpenCL для целевых вычислительных устройств.

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

Совсем недавно группа Khronos ратифицировала SYCL . модель программирования более высокого уровня для OpenCL в виде eDSL с одним исходным кодом, основанная на чистом C++17, для повышения производительности программирования . Люди, интересующиеся ядрами C++, но не стилем программирования с одним исходным кодом SYCL, могут использовать функции C++ с исходными кодами вычислительного ядра, написанными на языке «C++ for OpenCL».

Иерархия памяти

OpenCL определяет четырехуровневую иерархию памяти для вычислительного устройства:

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

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

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

Язык ядра OpenCL

Язык программирования, который используется для написания вычислительных ядер , называется языком ядра. OpenCL использует языки на основе C / C++ для определения вычислений ядра, выполняемых на устройстве, с некоторыми ограничениями и дополнениями для облегчения эффективного сопоставления с гетерогенными аппаратными ресурсами ускорителей. Традиционно OpenCL C использовался для программирования ускорителей в стандарте OpenCL, позже был разработан язык ядра C++ для OpenCL, который унаследовал всю функциональность от OpenCL C, но позволил использовать возможности C++ в исходных текстах ядра.

Язык OpenCL C

OpenCL C — это диалект языка на основе C99 , адаптированный для модели устройства в OpenCL. Буферы памяти располагаются на определенных уровнях иерархии памяти , а указатели помечаются квалификаторами региона. __Глобальный , __местный , __константа и __private , отражая это. Вместо программы устройства, имеющей основная функция, отмечены функции OpenCL C __kernel, чтобы сигнализировать о том, что они являются точками входа в программу, которая будет вызываться из хост-программы. Указатели функций , битовые поля и массивы переменной длины опускаются, а рекурсия запрещена. Стандартная библиотека C заменена специальным набором стандартных функций, предназначенных для математического программирования.

OpenCL C расширен для облегчения использования параллелизма с векторными типами и операциями, синхронизации и функций для работы с рабочими элементами и рабочими группами. В частности, помимо скалярных типов, таких как плавать и double , которые ведут себя аналогично соответствующим типам в C, OpenCL предоставляет векторные типы фиксированной длины, такие как float4 (4-вектор чисел с плавающей запятой одинарной точности); такие векторные типы доступны длиной два, три, четыре, восемь и шестнадцать для различных базовых типов. Векторизованные операции над этими типами предназначены для отображения на SIMD наборы инструкций , например, SSE или VMX , при запуске программ OpenCL на процессорах. Другие специализированные типы включают типы 2-х и 3-х мерных изображений.

Пример: умножение матрицы на вектор

Каждый вызов ( рабочий элемент ) ядра занимает строку зеленой матрицы ( A в коде), умножает эту строку на красный вектор ( x ) и помещает результат в запись синего вектора ( й ). Число столбцов n передается ядру как нколс ; количество строк подразумевает количество рабочих элементов, создаваемых главной программой.

Ниже приведен алгоритм умножения матрицы на вектор в OpenCL C.

// Умножает A*x, оставляя результат в y. 
  // A — матрица со строками, то есть элемент (i,j) находится в A[i*ncols+j]. 
  __kernel   void   matvec  (  __global   const   float   *  A  ,   __global   const   float   *  x  , 
                      uint   ncols  ,   __global   float   *  y  ) 
 { 
     size_t   i   =   get_global_id  (  0  );                 // Глобальный идентификатор, используемый в качестве индекса строки 
     __global   float   const   *  a   =   &  A  [  i  *  ncols  ];       // Указатель на i-ю строку 
     float   sum   =   0.f  ;                             // Аккумулятор для скалярного произведения 
     for   (  size_t   j   =   0  ;   j   <   ncols  ;   j  ++  )   { 
         sum   +=   a  [  j  ]   *   x  [  j  ]; 
      } 
     y  [  я  ]   знак равно   сумма  ; 
  } 

Функция ядра matvec вычисляет при каждом вызове скалярное произведение одной строки матрицы A и вектора x :

$$y_{i}=a_{i,:}\cdot x=\sum _{j}a_{i,j}x_{j}.$$

Чтобы расширить это до полного умножения матрицы на вектор, среда выполнения OpenCL сопоставляет ядро ​​со строками матрицы. На принимающей стороне Функция clEnqueueNDRangeKernel делает это; в качестве аргументов он принимает ядро, которое необходимо выполнить, его аргументы и количество рабочих элементов, соответствующее количеству строк в A. матрице

Пример: вычисление БПФ

В этом примере загрузится реализация быстрого преобразования Фурье (БПФ) и выполнится ее. Реализация показана ниже. Код запрашивает у библиотеки OpenCL первую доступную видеокарту, создает буферы памяти для чтения и записи (с точки зрения видеокарты), JIT-компилирует FFT-ядро и затем, наконец, асинхронно запускает ядро. В этом примере результат преобразования не считывается.

#include   <stdio.h> 
 #include   <time.h> 
 #include   "CL/opencl.h" 

 #define NUM_ENTRIES 1024 

 int   main  ()   // (int argc, const char* argv[]) 
 { 
	 // КОНСТАНТЫ 
	 // Исходный код ядра представлен в виде строки 
	 // расположенной внутри файла: "fft1D_1024_kernel_src.cl".   Подробности смотрите в следующем объявлении. 
	  const   char   *  KernelSource   = 
		 #include   "fft1D_1024_kernel_src.cl" 
			 ; 

	  // Поиск доступных графических процессоров 
	 const   cl_uint   num   =   1  ; 
	  clGetDeviceIDs  (  NULL  ,   CL_DEVICE_TYPE_GPU  ,   0  ,   NULL  ,   (  cl_uint  *  )  &  num  ); 

	 cl_device_id    устройства  [  1  ]; 
	  clGetDeviceIDs  (  NULL  ,   CL_DEVICE_TYPE_GPU  ,   num  ,   devices  ,   NULL  ); 

	  // создаем контекст вычислений с устройством графического процессора 
	 cl_context   context   =   clCreateContextFromType  (  NULL  ,   CL_DEVICE_TYPE_GPU  ,   NULL  ,   NULL  ,   NULL  ); 

	  // создаем очередь команд 
	 clGetDeviceIDs  (  NULL  ,   CL_DEVICE_TYPE_DEFAULT  ,   1  ,   devices  ,   NULL  ); 
	  cl_command_queue   очередь   =   clCreateCommandQueue  (  контекст  ,   устройства  [  0  ],   0  ,   NULL  ); 

	  // выделяем объекты буферной памяти 
	 cl_mem   memobjs  []   =   {   clCreateBuffer  (  context  ,   CL_MEM_READ_ONLY   |   CL_MEM_COPY_HOST_PTR  ,   sizeof  (  float  )   *   2   *   NUM_ENTRIES  ,   NULL  ,   NULL  ), 
						  clCreateBuffer  (  context  ,   CL_MEM_READ_WRITE ,   sizeof  (  float  )   *   2   *   NUM_ENTRIES  ,   NULL  ,   NULL  )   }; 

	  // создаем вычислительную программу 
	 // const char* fft1D_1024_kernel_src[1] = { }; 
	 cl_program    программа   =   clCreateProgramWithSource  (  контекст  ,   1  ,   (  const   char   **  )  &   KernelSource  ,   NULL  ,   NULL  ); 

	  // создаем исполняемый файл вычислительной программы 
	 clBuildProgram  (  program  ,   0  ,   NULL  ,   NULL  ,   NULL  ,   NULL  ); 

	  // создаем вычислительное ядро 
	 ​​cl_kernel   kernel   =   clCreateKernel  (  program  ,   "fft1D_1024"  ,   NULL  ); 

	  // устанавливаем значения аргументов 

	 size_t   local_work_size  [  1  ]   =   {   256   }; 

	  clSetKernelArg  (  kernel  ,   0  ,   sizeof  (  cl_mem  ),   (  void   *  )  &  memobjs  [  0  ]); 
	  clSetKernelArg  (  kernel  ,   1  ,   sizeof  (  cl_mem  ),   (  void   *  )  &  memobjs  [  1  ]); 
	  clSetKernelArg  (  kernel  ,   2  ,   sizeof  (  float  )  *  (  local_work_size  [  0  ]   +   1  )   *   16  ,   NULL  ); 
	  clSetKernelArg  (  kernel  ,   3  ,   sizeof  (  float  )  *  (  local_work_size  [  0  ]   +   1  )   *   16  ,   NULL  ); 

	  // создаем объект диапазона ND с размерами рабочего элемента и выполняем ядро 
	 ​​size_t   global_work_size  [  1  ]   =   {   256   }; 
	
	  global_work_size  [  0  ]   =   NUM_ENTRIES  ; 
	  local_work_size  [  0  ]   =   64  ;    //Nvidia: 192 или 256 
	 clEnqueueNDRangeKernel  (  очередь  ,   ядро  ,   1  ,   NULL  ,   global_work_size  ,   local_work_size  ,   0  ,   NULL  ,   NULL  ); 
  } 

Фактический расчет внутри файла «fft1D_1024_kernel_src.cl» (на основе «Подгонка БПФ к архитектуре G80»):

R  "( 
   // Это ядро ​​вычисляет БПФ длиной 1024. БПФ длиной 1024 разбивается на 
   // вызовы функции счисления 16, другой функции счисления 16 и затем функции счисления 4 

   __kernel   void   fft1D_1024   (  __global   float2   *  in  ,   __global   float2   *  out  , 
                           __local   float   *  sMemx  ,   __local   float   *  sMemy  )   { 
     int   tid   =   get_local_id  (  0  ); 
     int   blockIdx   =   get_group_id  (  0  )   *   1024   +   tid  ; 
     float2   data  [  16  ] 

     // начальный индекс данных в/из global; Memory 
     in   =   in   +   blockIdx  ;    out   =   out   +   blockIdx  ; 

     globalLoads  (  data  ,   in  ,   64  );   // объединенные глобальные чтения 
     fftRadix16Pass  (  data  );        // передача по основанию radix-16 
     twiddleFactorMul  (  data  ,   tid  ,   1024  ,   0).  ); 

     перемешивание с использованием локальной памяти 
     localShuffle  (  data  ,   sMemx  ,   sMemy  ,   tid  ,   (  tid   &   15  )   *   65  )   +   (  (   //   data  ; 
     fftRadix16Pass  (  (  )                 локальное  -16 pass 
     twiddleFactorMul  (  data  ,   tid  ,   64  ,   4  );   // умножение коэффициента вращения 

     localShuffle  (  data  ,   sMemx  ,   sMemy  ,   tid  ,   (((  tid   >>   4  )   *   64  )   +   (  tid   &   15  ))) 

     / / четыре вызова функции счисления radix-4 
     fftRadix4Pass  (  data  );         // функция по основанию radix-4, номер 1 
     fftRadix4Pass  (  data   +   4  );     // функция по основанию radix-4, номер 2 
     fftRadix4Pass  (  data   +   8  );     // функция счисления 4 счисления номер 3 
     fftRadix4Pass (  данные   +   12  );    // функция по системе счисления 4, номер 4 

     // объединенные глобальные записи 
     globalStores  (  data  ,   out  ,   64  ); 
    } 
 )  " 

Полную реализацию OpenCL FFT с открытым исходным кодом можно найти на веб-сайте Apple.

C++ для языка OpenCL

В 2020 году Хронос объявил переход на C++, управляемый сообществом, для языка программирования OpenCL который предоставляет функции C++17 в сочетании с традиционными функциями OpenCL C. Этот язык позволяет использовать богатое разнообразие языковых функций стандартного C++, сохраняя при этом обратную совместимость с OpenCL C. Это открывает плавный путь перехода к функциональности C++ для разработчиков кода ядра OpenCL, поскольку они могут продолжать использовать знакомый процесс программирования и даже инструменты в качестве а также использовать существующие расширения и библиотеки, доступные для OpenCL C.

Семантика языка описана в документации, опубликованной в выпусках OpenCL-Docs. репозиторий, размещенный Khronos Group, но в настоящее время не ратифицирован Khronos Group. Язык C++ для OpenCL не документирован в отдельном документе и основан на спецификации C++ и OpenCL C. Компилятор Clang с открытым исходным кодом поддерживает C++ для OpenCL начиная с версии 9.

C++ для OpenCL изначально был разработан как расширение компилятора Clang и появился в версии 9. Поскольку он был тесно связан с OpenCL C и не содержал каких-либо специфических для Clang функций, его документация была перенесена в репозиторий OpenCL-Docs. от Khronos Group вместе с источниками других спецификаций и справочных карточек. Первый официальный выпуск этого документа, описывающий C++ для OpenCL версии 1.0, был опубликован в декабре 2020 года. C++ для OpenCL 1.0 содержит функции C++17 и обратно совместим с OpenCL C 2.0. В декабре 2021 года была выпущена новая предварительная версия C++ для OpenCL версии 2021, полностью совместимая со стандартом OpenCL 3.0. Незавершенный проект последней версии документации C++ для OpenCL можно найти на веб-сайте Khronos.

Особенности

C++ для OpenCL поддерживает большинство функций (синтаксически и семантически) OpenCL C, за исключением вложенного параллелизма и блоков. Однако в некоторых поддерживаемых функциях имеются незначительные различия, в основном связанные с различиями в семантике между C++ и C. Например, C++ более строг в отношении неявных преобразований типов и не поддерживает квалификатор ограничивающего типа. Следующие функции C++ не поддерживаются C++ для OpenCL: виртуальные функции, оператор Dynamic_cast , неразмещение новый / операторы удаления , исключения, указатель на функции-члены, ссылки на функции, стандартные библиотеки C++. C++ для OpenCL расширяет концепцию отдельных областей памяти ( адресных пространств ) из OpenCL C на возможности C++ — функциональные приведения, шаблоны, члены классов, ссылки, лямбда-функции и операторы. Большинство функций C++ недоступны для функций ядра, например, перегрузка или шаблонизация, произвольное расположение классов в типе параметра.

Пример: арифметика комплексных чисел

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

// Определить класс Complex, который может выполнять вычисления комплексных чисел с 
 // различной точностью, когда используются разные типы T - double, float, half. 
  шаблон  <  имя типа   T  > 
 класс   complex_t   { 
     T   m_re  ;    // Реальный компонент. 
      Т   м_им  ;    // Мнимая компонента. 

  public  : 
     complex_t  (  T   re  ,   T   im  )  :   m_re  {  re  },   m_im  {  im  }   {}; 
      // Определить оператор для умножения комплексных чисел. 
      complex_t   оператор  *  (  const   complex_t   и  другое  )   const 
     { 
         return   {  m_re   *   другое  .   m_re   -   m_im   *   другое  .   м_им  ,  
                 м_ре   *   другое  .   m_im   +   m_im   *   другое  .   м_ре  }; 
      } 
     T   get_re  ()   const   {   return   m_re  ;    } 
     T   get_im  ()   const   {   return   m_im  ;    } 
 }; 

  // Вспомогательная функция для вычисления умножения комплексных чисел, считанных из 
 // входного буфера, и сохранения вычисленного результата в выходном буфере. 
  шаблон  <  имя типа   T  > 
 void   Compute_helper  (  __global   T   *  in  ,   __global   T   *  out  )   { 
     auto   idx   =   get_global_id  (  0  );     
      // Каждый рабочий элемент использует 4 последовательных элемента из входного буфера 
     // - по два для каждого комплексного числа. 
      автоматическое   смещение   =   idx   *   4  ; 
      auto   num1   =   complex_t  {  в  [  смещение  ],   в  [  смещение   +   1  ]}; 
      auto   num2   =   complex_t  {  в  [  смещение   +   2  ],   в  [  смещение   +   3  ]}; 
      // Выполняем умножение комплексных чисел. 
    автоматическое   разрешение   =   число1   *   число2  ; 
      // Каждый рабочий элемент записывает 2 последовательных элемента в выходной буфер. 
      выход  [  idx   *   2  ]   =   рез  .   получить_ре  (); 
      out  [  idx   *   2   +   1  ]   =   рез  .   получить_им  (); 
  } 

 // Это ядро ​​используется для умножения комплексных чисел с одинарной точностью. 
  __kernel   void   Compute_sp  (  __global   float   *  in  ,   __global   float   *  out  )   { 
     compute_helper  (  in  ,   out  ); 
  } 

 #ifdef cl_khr_fp16 
 // Это ядро ​​используется для умножения комплексных чисел с половинной точностью, если 
 // оно поддерживается устройством. 
  #pragma OPENCL EXTENSION cl_khr_fp16: включить 
 __kernel   void   Compute_hp  (  __global   half   *  in  ,   __global   half   *  out  )   { 
     Compute_helper  (  in  ,   out  );  
  } 
 #конециф 

Инструментарий и среда исполнения

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

Исходники C++ для OpenCL могут быть скомпилированы драйверами OpenCL, поддерживающими расширение cl_ext_cxx_for_opencl . Компания Arm объявила о поддержке этого расширения в декабре 2020 года. Однако из-за растущей сложности алгоритмов, ускоряемых на устройствах OpenCL, ожидается, что все больше приложений будут компилировать C++ для ядер OpenCL в автономном режиме с использованием автономных компиляторов, таких как Clang. в исполняемый двоичный формат или переносимый двоичный формат, например SPIR-V. Такой исполняемый файл можно загрузить во время выполнения приложений OpenCL с помощью специального API OpenCL.

Двоичные файлы, скомпилированные из исходных кодов C++ для OpenCL 1.0, могут выполняться на устройствах, совместимых с OpenCL 2.0. В зависимости от особенностей языка, используемых в таких исходных кодах ядра, его также можно выполнять на устройствах, поддерживающих более ранние версии OpenCL или OpenCL 3.0.

Помимо драйверов OpenCL, ядра, написанные на C++ для OpenCL, можно скомпилировать для выполнения на устройствах Vulkan с помощью clspv. компилятор и clvk уровень времени выполнения точно так же, как и ядра OpenCL C.

Взносы

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

История

OpenCL изначально был разработан компанией Apple Inc. , владеющей правами на товарные знаки , и доработан до первоначального предложения в сотрудничестве с техническими группами AMD , IBM , Qualcomm , Intel и Nvidia . Apple представила это первоначальное предложение Khronos Group . 16 июня 2008 года была сформирована рабочая группа Khronos Compute. с представителями компаний, занимающихся процессорами, графическими процессорами, встроенными процессорами и программным обеспечением. Эта группа работала в течение пяти месяцев, чтобы завершить технические детали спецификации OpenCL 1.0 к 18 ноября 2008 года. Эта техническая спецификация была рассмотрена участниками Khronos и одобрена для публичного выпуска 8 декабря 2008 г.

OpenCL 1.0

OpenCL 1.0 выпущен вместе с Mac OS X Snow Leopard 28 августа 2009 г. Согласно пресс-релизу Apple:

Snow Leopard дополнительно расширяет поддержку современного оборудования с помощью Open Computing Language (OpenCL), который позволяет любому приложению использовать огромные гигафлопс вычислительной мощности графического процессора, ранее доступной только графическим приложениям. OpenCL основан на языке программирования C и был предложен в качестве открытого стандарта.

AMD решила поддерживать OpenCL вместо устаревшего Close to Metal в своем фреймворке Stream . RapidMind объявила о внедрении OpenCL в свою платформу разработки для поддержки графических процессоров от нескольких поставщиков с помощью одного интерфейса. 9 декабря 2008 года Nvidia объявила о своем намерении добавить полную поддержку спецификации OpenCL 1.0 в свой набор инструментов для вычислений на графическом процессоре. 30 октября 2009 года IBM выпустила свою первую реализацию OpenCL в составе компиляторов XL .

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

OpenCL 1.1

OpenCL 1.1 был ратифицирован Khronos Group 14 июня 2010 г. и добавляет значительные функциональные возможности для повышения гибкости, функциональности и производительности параллельного программирования, включая:

• Новые типы данных, включая трехкомпонентные векторы и дополнительные форматы изображений;
• Обработка команд из нескольких потоков хоста и буферов обработки на нескольких устройствах;
• Операции с областями буфера, включая чтение, запись и копирование прямоугольных 1D, 2D или 3D областей;
• Расширенное использование событий для управления и контроля выполнения команд;
• Дополнительные встроенные функции C OpenCL, такие как целочисленное ограничение, перемешивание и асинхронное пошаговое копирование;
• Улучшена совместимость OpenGL за счет эффективного совместного использования изображений и буферов путем связывания событий OpenCL и OpenGL.

OpenCL 1.2

15 ноября 2011 года Khronos Group анонсировала спецификацию OpenCL 1.2. что добавило значительную функциональность по сравнению с предыдущими версиями с точки зрения производительности и возможностей параллельного программирования. Наиболее примечательные особенности включают в себя:

• Разделение устройства: возможность разделить устройство на подустройства, чтобы рабочие задания можно было распределять по отдельным вычислительным блокам. Это полезно для резервирования областей устройства, чтобы уменьшить задержку для задач, критичных по времени.
• Раздельная компиляция и связывание объектов: возможность компилировать OpenCL во внешние библиотеки для включения в другие программы.
• Расширенная поддержка изображений (дополнительно): в версии 1.2 добавлена ​​поддержка 1D-изображений и массивов 1D/2D-изображений. Кроме того, расширения совместного использования OpenGL теперь позволяют использовать 1D-текстуры OpenGL и массивы 1D/2D-текстур для создания изображений OpenCL.
• Встроенные ядра: специальные устройства, обладающие особыми уникальными функциями, теперь более тесно интегрированы в структуру OpenCL. Ядра можно вызывать для использования специализированных или непрограммируемых аспектов базового оборудования. Примеры включают кодирование/декодирование видео и процессоры цифровых сигналов.
• Функциональность DirectX: совместное использование медиа-поверхностей DX9 обеспечивает эффективный обмен между OpenCL и медиа-поверхностями DX9 или DXVA . Аналогичным образом, для DX11 включено плавное совместное использование поверхностей OpenCL и DX11.
• Возможность обеспечить соответствие стандарту IEEE 754 для математических операций с плавающей запятой одинарной точности: OpenCL по умолчанию позволяет версиям операций деления, обратного вычисления и извлечения квадратного корня с одинарной точностью быть менее точными, чем правильно округленные значения, которых требует IEEE 754. Если программист передает компилятору аргумент командной строки «-cl-fp32-correctly-rounded-divide-sqrt», эти три операции будут вычислены в соответствии с требованиями IEEE 754, если реализация OpenCL поддерживает это, и не смогут скомпилироваться, если Реализация OpenCL не поддерживает вычисление этих операций до их правильно округленных значений, как это определено спецификацией IEEE 754. Эта возможность дополняется возможностью запроса реализации OpenCL, чтобы определить, может ли она выполнять эти операции с точностью IEEE 754.

OpenCL 2.0

18 ноября 2013 года Khronos Group объявила о ратификации и публичном выпуске окончательной версии спецификации OpenCL 2.0. Обновления и дополнения к OpenCL 2.0 включают:

• Общая виртуальная память
• Вложенный параллелизм
• Общее адресное пространство
• Изображения (необязательно, включая 3D-изображение)
• C11 атомы
• Трубы
• Android Расширение устанавливаемого клиентского драйвера
• половинная точность расширена с помощью дополнительного расширения cl_khr_fp16
• cl_double: двойная точность IEEE 754 (необязательно).

OpenCL 2.1

О ратификации и выпуске предварительной спецификации OpenCL 2.1 было объявлено 3 марта 2015 года на конференции разработчиков игр в Сан-Франциско. Он был выпущен 16 ноября 2015 года. Он представил язык ядра OpenCL C++, основанный на подмножестве C++14 , сохраняя при этом поддержку ранее существовавшего языка ядра OpenCL C. Vulkan и OpenCL 2.1 используют SPIR-V в качестве промежуточного представления , позволяющего интерфейсам на языках высокого уровня использовать общую цель компиляции. Обновления API OpenCL включают в себя:

• Дополнительный функционал подгруппы
• Копирование объектов и состояний ядра
• Запросы таймера устройства с малой задержкой
• Прием кода SPIR-V во время выполнения
• Подсказки по приоритету выполнения для очередей
• Отправки нулевого размера от хоста

AMD, ARM , Intel, HPC и YetiWare заявили о поддержке OpenCL 2.1.

OpenCL 2.2

OpenCL 2.2 включает язык ядра OpenCL C++ в базовую спецификацию, что значительно повышает производительность параллельного программирования. Он был выпущен 16 мая 2017 года. Обновление обслуживания, выпущенное в мае 2018 г., с исправлениями ошибок.

• Язык ядра OpenCL C++ представляет собой статическое подмножество стандарта C++14 и включает классы, шаблоны, лямбда-выражения, перегрузки функций и многие другие конструкции для универсального и метапрограммирования.
• Использует новый промежуточный язык Khronos SPIR-V 1.1, который полностью поддерживает язык ядра OpenCL C++.
• Функции библиотеки OpenCL теперь могут использовать язык C++, чтобы обеспечить повышенную безопасность и уменьшить неопределенное поведение при доступе к таким функциям, как атомы, итераторы, изображения, сэмплеры, каналы и встроенные типы очередей устройств и адресные пространства.
• Конвейерное хранилище — это новый тип на стороне устройства в OpenCL 2.2, который полезен для реализаций FPGA, поскольку размер и тип соединения становятся известны во время компиляции, что обеспечивает эффективную связь между ядрами на уровне устройства.
• OpenCL 2.2 также включает функции улучшенной оптимизации сгенерированного кода: приложения могут предоставлять значение константы специализации во время компиляции SPIR-V, новый запрос может обнаруживать нетривиальные конструкторы и деструкторы глобальных объектов области программы, а также могут быть установлены пользовательские обратные вызовы. во время выпуска программы.
• Работает на любом оборудовании с поддержкой OpenCL 2.0 (требуется только обновление драйвера).

OpenCL 3.0

Спецификация OpenCL 3.0 была выпущена 30 сентября 2020 года после того, как с апреля 2020 года она находилась в предварительной версии. Функциональность OpenCL 1.2 стала обязательной базовой, а все функции OpenCL 2.x и OpenCL 3.0 стали необязательными. Спецификация сохраняет язык OpenCL C и объявляет устаревшим язык ядра OpenCL C++, заменяя его языком C++ для OpenCL. на основе компилятора Clang / LLVM , который реализует подмножество промежуточного кода C++17 и SPIR-V . Версия 3.0.7 C++ для OpenCL с некоторыми расширениями Khronos openCL была представлена ​​на IWOCL 21. Актуальная версия — 3.0.11 с некоторыми новыми расширениями и исправлениями. NVIDIA в тесном сотрудничестве с рабочей группой Khronos OpenCL улучшила Vulkan Interop с помощью семафоров и совместного использования памяти. Последнее незначительное обновление было 3.0.14 с исправлением ошибок и новым расширением для нескольких устройств.

Дорожная карта

Международный семинар по OpenCL (IWOCL), проводимый Khronos Group

Выпуская OpenCL 2.2, группа Khronos объявила, что OpenCL будет, где это возможно, сходиться с Vulkan , чтобы обеспечить гибкость развертывания программного обеспечения OpenCL через оба API. Это было продемонстрировано Adobe Premiere Rush с использованием clspv. компилятор с открытым исходным кодом для компиляции значительных объемов кода ядра OpenCL C для запуска в среде выполнения Vulkan для развертывания на Android. OpenCL имеет перспективную дорожную карту, независимую от Vulkan: OpenCL Next находится в стадии разработки и планируется выпустить в 2020 году. OpenCL Next может интегрировать такие расширения, как Vulkan / OpenCL Interop, Scratch-Pad Memory Management, расширенные подгруппы, прием SPIR-V 1.4 и SPIR-V Расширенная отладочная информация. OpenCL также рассматривает загрузчик и уровни, подобные Vulkan, а также «гибкий профиль» для гибкого развертывания на нескольких типах ускорителей.

Реализации с открытым исходным кодом

clinfo, инструмент командной строки для просмотра информации OpenCL

OpenCL состоит из набора заголовков и общего объекта , загружаемого во время выполнения. Устанавливаемый клиентский драйвер (ICD) должен быть установлен на платформе для каждого класса поставщиков, которого должна поддерживать среда выполнения. То есть, например, для поддержки устройств Nvidia на платформе Linux необходимо установить ICD Nvidia так, чтобы среда выполнения OpenCL (загрузчик ICD) могла найти ICD поставщика и соответствующим образом перенаправить вызовы. . Стандартный заголовок OpenCL используется потребительским приложением; вызовы каждой функции затем передаются средой выполнения OpenCL соответствующему драйверу с помощью ICD. Каждый поставщик должен реализовать каждый вызов OpenCL в своем драйвере.

Яблоко, Нвидиа, РОКм , RapidMind и Галлий3D Все реализации OpenCL основаны на технологии компилятора LLVM и используют компилятор Clang в качестве внешнего интерфейса.

MESA Галлиевые вычисления

Реализация OpenCL (фактическая версия 1.1 неполная, в основном сделана AMD Radeon GCN ) для ряда платформ поддерживается в рамках проекта Gallium Compute Project. который основан на работе проекта Mesa для поддержки нескольких платформ. Раньше это было известно как КЛЕВЕР. фактическая разработка: в основном поддержка запуска неполной среды с реальными LLVM и CLANG, некоторые новые функции, такие как fp16 в 17.3, Целевая полная версия OpenCL 1.0, 1.1 и 1.2 для AMD и Nvidia. Новая базовая разработка выполняется Red Hat с использованием SPIR-V, а также для Clover. New Target представляет собой модульный OpenCL 3.0 с полной поддержкой OpenCL 1.2. Фактическое состояние доступно в Mesamatrix. Поддержка изображений здесь находится в центре внимания разработки.

RustiCL — это новая реализация вычислений Gallium с использованием Rust вместо C. В Mesa 22.2 доступна экспериментальная реализация с поддержкой openCL 3.0 и реализацией расширения изображений для таких программ, как Darktable. Intel Xe (Arc) и AMD GCN+ поддерживаются в Mesa 22.3+. AMD R600 и Nvidia Kepler+ также подлежат аппаратной поддержке. RustiCL превосходит AMD ROCM с оборудованием Radeon RX 6700 XT в тесте Luxmark Benchmark. Mesa 23.1 поддерживает официальный RustiCL. В Mesa 23.2 поддержка важного fp64 находится на экспериментальном уровне.

Microsoft от В Windows 11 на Arm добавлена ​​поддержка OpenCL 1.2 через CLon12, реализацию OpenCL с открытым исходным кодом поверх DirectX 12 через Mesa Gallium .

ПОНЧИК

Реализация Intel для своего оборудования Ivy Bridge+ была выпущена в 2013 году. Это программное обеспечение от китайской команды Intel вызвало критику со стороны разработчиков AMD и Red Hat . а также Майкл Ларабель из Phoronix . Актуальная версия 1.3.2 поддерживает полную версию OpenCL 1.2 (Ivy Bridge и выше) и опциональную OpenCL 2.0 для Skylake и новее. В Beignet добавлена ​​поддержка Android., актуальные цели разработки: поддержка только 1.2 и 2.0, путь к OpenCL 2.1, 2.2, 3.0 пройден в NEO.

НЕО

Реализация Intel для аппаратного обеспечения Broadwell 8-го поколения + 9-го поколения, выпущенного в 2018 году. Этот драйвер заменяет реализацию Beignet для поддерживаемых платформ (не старше 6.gen на Haswell). NEO обеспечивает поддержку OpenCL 2.1 на платформах Core и OpenCL 1.2 на платформах Atom. В 2020 году также поддерживаются графические процессоры Gen 11 Ice Lake и Gen 12 Tiger Lake. Новый OpenCL 3.0 доступен для Alder Lake, Tiger Lake и Broadwell с версией 20.41+. Теперь он включает в себя дополнительные функции OpenCL 2.0, 2.1 и некоторые функции 2.2.

РПЦм

(Radeon Open Compute) , созданный как часть AMD GPUOpen , ROCm представляет собой проект Linux с открытым исходным кодом, построенный на OpenCL 1.2 с поддержкой языка 2.0. Система совместима со всеми современными процессорами и APU AMD (фактически частично с GFX 7, GFX 8 и 9), а также с процессорами Intel Gen7.5+ (только с PCI 3.0). В версии 1.9 поддержка в некоторых случаях расширена экспериментально до оборудования с PCIe 2.0 и без атомов. Обзор фактической работы сделан на XDC2018. ROCm версии 2.0 поддерживает полную версию OpenCL 2.0, но в списке задач есть некоторые ошибки и ограничения. Версия 3.3 совершенствуется в деталях. Версия 3.5 поддерживает OpenCL 2.2. Версия 3.10 содержала улучшения и новые API. На SC20 было анонсировано ROCm 4.0 с поддержкой AMD Compute Card Instinct MI 100. Актуальная документация по версии 5.5.1 и более ранним доступна на GitHub. Доступен OpenCL 3.0. RocM 5.5.x+ поддерживает только GFX 9 Vega и новее, поэтому альтернативой являются более старые версии RocM или будущий RustiCL для более старого оборудования.

ПОКЛ

Портативная реализация, поддерживающая процессоры и некоторые графические процессоры (через CUDA и HSA ). Опираясь на Clang и LLVM . В версии 1.0 OpenCL 1.2 был почти полностью реализован вместе с некоторыми функциями 2.x. Версия 1.2 имеет LLVM/CLANG 6.0, 7.0 и полную поддержку OpenCL 1.2 со всеми закрытыми заявками в Milestone 1.2. OpenCL 2.0 реализован почти полностью. Версия 1.3 поддерживает Mac OS X. Версия 1.4 включает поддержку LLVM 8.0 и 9.0. Версия 1.5 реализует поддержку LLVM/Clang 10. Версия 1.6 реализует поддержку LLVM/Clang 11 и ускорение CUDA. Фактические цели — полная реализация OpenCL 2.x, OpenCL 3.0 и улучшение производительности. POCL 1.6 имеет ручную оптимизацию на том же уровне, что и среда выполнения вычислений Intel. Версия 1.7 реализует поддержку LLVM/Clang 12 и некоторые новые функции OpenCL 3.0. Версия 1.8 реализует поддержку LLVM/Clang 13. Версия 3.0 реализует OpenCL 3.0 на минимальном уровне и LLVM/Clang 14. Версия 3.1 работает с LLVM/Clang 15 и имеет улучшенную поддержку Spir-V.

Шемрок

Порт Mesa Clover для ARM с полной поддержкой OpenCL 1.2. нет фактической разработки для 2.0.

FreeOCL

Реализация OpenCL 1.2, ориентированная на ЦП, которая реализует внешний компилятор для создания более надежной платформы. никакого реального развития.

МОКЛ

Реализация OpenCL на основе POCL, разработанная исследователями NUDT для Matrix-2000, была выпущена в 2018 году. Архитектура Matrix-2000 предназначена для замены ускорителей Intel Xeon Phi суперкомпьютера TianHe-2. Эта среда программирования построена на основе LLVM v5.0 и также повторно использует некоторые фрагменты кода из POCL. Чтобы раскрыть потенциал оборудования, среда выполнения устройства использует стратегию диспетчеризации задач на основе push, а производительность атомарности ядра значительно повышается. Эта структура была развернута в системе TH-2A и легко доступна для общественности. Некоторое программное обеспечение будет затем портировано для улучшения POCL.

VC4CL

Реализация OpenCL 1.2 для процессора VideoCore IV (BCM2763), который использовался в Raspberry Pi до его модели 4.

Реализации поставщиков

Хронология внедрения поставщиками

• Июнь 2008 г.: во время конференции Apple WWDC участникам была доступна ранняя бета-версия Mac OS X Snow Leopard , включающая первую бета-версию OpenCL, примерно за 6 месяцев до того, как окончательная спецификация версии 1.0 была ратифицирована в конце 2008 года. Они также показали две демоверсии. Один представлял собой сетку из отображаемых экранов 8×8, каждый из которых отображал экран эмулируемого компьютера Apple II — всего 64 независимых экземпляра, на каждом из которых выполнялась знаменитая игра по каратэ. Это показало параллелизм задач на ЦП. Другая демонстрация представляла собой симуляцию N тел, выполняемую на графическом процессоре Mac Pro, — задачу параллельного обмена данными.
• 10 декабря 2008 г.: AMD и Nvidia провели первую публичную демонстрацию OpenCL, 75-минутную презентацию на выставке SIGGRAPH Asia 2008. AMD продемонстрировала демо-версию OpenCL с процессорным ускорением, объясняющую масштабируемость OpenCL на одном или нескольких ядрах, в то время как Nvidia продемонстрировала версию OpenCL с ускорением на графическом процессоре. демо.
• 16 марта 2009 г.: на 4-й выставке Multicore Expo компания Imagination Technologies анонсировала PowerVR SGX543MP, первый графический процессор этой компании с поддержкой OpenCL.
• 26 марта 2009 г.: на GDC 2009 компании AMD и Havok продемонстрировали первую рабочую реализацию OpenCL, ускоряющую Havok Cloth на графическом процессоре ATI Radeon HD 4000 серии .
• 20 апреля 2009 г.: Nvidia объявила о выпуске драйвера OpenCL и SDK для разработчиков, участвующих в программе раннего доступа OpenCL.
• 5 августа 2009 г.: AMD представила первые инструменты разработки для своей платформы OpenCL в рамках бета-программы ATI Stream SDK v2.0.
• 28 августа 2009 г.: Apple выпустила Mac OS X Snow Leopard , которая содержит полную реализацию OpenCL.
• 28 сентября 2009 г.: Nvidia выпустила собственные драйверы OpenCL и реализацию SDK.
• 13 октября 2009 г.: AMD выпустила четвертую бета-версию ATI Stream SDK 2.0, которая обеспечивает полную реализацию OpenCL как на R700 / HD 5000 графических процессорах , так и на процессорах с поддержкой SSE3 . SDK доступен как для Linux, так и для Windows.
• 26 ноября 2009 г.: Nvidia выпустила драйверы для OpenCL 1.0 (версия 48).
• 27 октября 2009 г.: S3 выпустила свой первый продукт с поддержкой OpenCL 1.0 — встроенный графический процессор Chrome 5400E.
• 10 декабря 2009 г.: VIA выпустила свой первый продукт с поддержкой OpenCL 1.0 — видеопроцессор ChromotionHD 2.0, включенный в набор микросхем VN1000.
• 21 декабря 2009 г.: AMD выпустила производственную версию ATI Stream SDK 2.0. который обеспечивает поддержку OpenCL 1.0 для графических процессоров HD 5000 и бета-поддержку для графических процессоров R700 .
• 1 июня 2010 г.: ZiiLABS опубликовала подробную информацию о своей первой реализации OpenCL для процессора ZMS для портативных, встраиваемых и цифровых домашних продуктов.
• 30 июня 2010 г.: IBM выпустила полностью совместимую версию OpenCL 1.0.
• 13 сентября 2010 г.: Intel опубликовала подробности своей первой реализации OpenCL для архитектуры чипов Sandy Bridge. Sandy Bridge интегрирует новейшую технологию графических чипов Intel непосредственно в центральный процессор.
• 15 ноября 2010 г.: Wolfram Research выпустила Mathematica 8 с OpenCLLink. упаковка.
• 3 марта 2011 г.: Khronos Group объявляет о создании рабочей группы WebCL для изучения определения привязки JavaScript к OpenCL. Это создает возможность использовать параллельную обработку графического процессора и многоядерного процессора из веб-браузера .
• 31 марта 2011 г.: IBM выпустила полностью совместимую версию OpenCL 1.1.
• 25 апреля 2011 г.: IBM выпустила OpenCL Common Runtime v0.1 для Linux на архитектуре x86.
• 4 мая 2011 г.: Nokia Research выпускает расширение WebCL с открытым исходным кодом для веб-браузера Firefox , обеспечивающее привязку JavaScript к OpenCL.
• 1 июля 2011 г.: Samsung Electronics выпускает прототип реализации WebCL с открытым исходным кодом для WebKit, обеспечивающий привязку JavaScript к OpenCL.
• 8 августа 2011 г.: AMD выпустила комплект разработки программного обеспечения AMD Accelerated Parallel Processing (APP) v2.5 на базе OpenCL, заменив ATI Stream SDK как технологию и концепцию.
• 12 декабря 2011 г.: AMD выпустила AMD APP SDK v2.6. который содержит предварительную версию OpenCL 1.2.
• 27 февраля 2012 г.: Portland Group выпустила компилятор PGI OpenCL для многоядерных ARM . процессоров
• 17 апреля 2012 г.: Khronos выпустил рабочий проект WebCL.
• 6 мая 2013 г.: Altera выпустила Altera SDK для OpenCL версии 13.0. Он соответствует OpenCL 1.0.
• 18 ноября 2013 г.: Хронос объявил, что спецификация OpenCL 2.0 завершена.
• 19 марта 2014 г.: Khronos выпускает спецификацию WebCL 1.0.
• 29 августа 2014 г.: Intel выпускает драйвер HD Graphics 5300, поддерживающий OpenCL 2.0.
• 25 сентября 2014 г.: AMD выпускает Catalyst 14.41 RC1, который включает драйвер OpenCL 2.0.
• 14 января 2015 г.: Xilinx Inc. объявляет о выпуске среды разработки SDAccel для OpenCL, C и C++, достижения соответствия Khronos.
• 13 апреля 2015 г.: Nvidia выпускает драйвер WHQL v350.12, который включает поддержку OpenCL 1.2 для графических процессоров на базе архитектуры Kepler или более поздних версий. Driver 340+ поддерживает OpenCL 1.1 для Tesla и Fermi.
• 26 августа 2015 г.: AMD выпустила AMD APP SDK v3.0. который содержит полную поддержку OpenCL 2.0 и примеры кода.
• 16 ноября 2015 г.: Хронос объявил, что спецификация OpenCL 2.1 завершена.
• 18 апреля 2016 г.: Хронос объявил, что спецификация OpenCL 2.2 предварительно завершена.
• 3 ноября 2016 г.: поддержка Intel Gen7+ OpenCL 2.1 в SDK 2016 r3.
• 17 февраля 2017 г.: Nvidia начинает ознакомительную поддержку OpenCL 2.0 с драйвером 378.66.
• 16 мая 2017 г.: Khronos объявил, что спецификация OpenCL 2.2 была дополнена SPIR-V 1.2.
• 14 мая 2018 г.: Khronos анонсировал обновление для OpenCL 2.2 с исправлением ошибок и унифицированными заголовками.
• 27 апреля 2020 г.: Khronos анонсировал предварительную версию OpenCL 3.0.
• 1 июня 2020 г.: среда выполнения Intel Neo с OpenCL 3.0 для нового Tiger Lake.
• 3 июня 2020 г.: AMD анонсировала RocM 3.5 с поддержкой OpenCL 2.2.
• 30 сентября 2020 г.: Khronos объявил, что спецификации OpenCL 3.0 завершены (также доступен CTS).
• 16 октября 2020 г.: Intel объявила о поддержке Neo 20.41 OpenCL 3.0 (включает в себя в основном дополнительный OpenCL 2.x).
• 6 апреля 2021 г.: Nvidia поддерживает OpenCL 3.0 для Ampere. Графические процессоры Maxwell и более поздних версий также поддерживают OpenCL 3.0 с драйвером Nvidia 465+.
• 20 августа 2022 г.: графические процессоры Intel Arc Alchemist (Arc A380, A350M, A370M, A550M, A730M и A770M) соответствуют OpenCL 3.0.
• 14 октября 2022 г.: Arm Mali-G615 и Mali-G715-Immortal совместимы с OpenCL 3.0.
• 11 ноября 2022 г.: библиотека RustiCL OpenCL соответствует OpenCL 3.0.

Устройства

По состоянию на 2016 год OpenCL работает на графических процессорах (GPU), процессорах с инструкциями SIMD , FPGA , Movidius Myriad 2 , Adapteva Epiphany и DSP .

Набор тестов

Чтобы быть официально соответствующей, реализация должна пройти набор тестов на соответствие Khronos (CTS), а результаты должны быть отправлены в программу Khronos Adopters Program. Код Khronos CTS для всех версий OpenCL доступен в открытом исходном коде с 2017 года.

Соответствующие продукты

Группа Khronos поддерживает расширенный список продуктов, совместимых с OpenCL.

Краткий обзор продуктов, совместимых с OpenCL
SDK AMD (поддерживает устройства OpenCL CPU и APU ), (GPU: Terascale 1: OpenCL 1.1, Terascale 2: 1.2, GCN 1: 1.2+, GCN 2+: 2.0+)	X86 + SSE2 (или выше) совместимые процессоры, 64-битные и 32-битные , ПК с Linux 2.6, ПК с Windows Vista/7/8.x/10	AMD Fusion E-350, E-240, C-50, C-30 с HD 6310/HD 6250	AMD Radeon /Mobility HD 6800, графический процессор серии HD 5x00, iGPU HD 6310/HD 6250, HD 7xxx, HD 8xxx, R2xx, R3xx, RX 4xx, RX 5xx, серия Vega	Графический процессор AMD FirePro серии Vx800 и более поздних версий, Radeon Pro
Intel SDK для приложений OpenCL 2013 (поддерживает процессоры Intel Core и Intel HD Graphics 4000/2500) 2017 R2 с OpenCL 2.1 (Gen7+), SDK 2019 удален OpenCL 2.1, Актуальное обновление SDK 2020 3.	Intel Процессоры с поддержкой SSE 4.1, SSE 4.2 или AVX . Microsoft Windows , Линукс	Intel Core i7 , i5 , i3 ; Процессоры Intel Core i7/5/3 2-го поколения, процессоры Intel Core 3-го поколения с графикой Intel HD Graphics 4000/2500 и новее	Intel Core 2 Solo, Duo Quad, Extreme и новее	Intel Xeon 7x00,5x00,3x00 (на базе ядра) и новее
IBM Серверы с комплектом разработки OpenCL для Linux on Power, работающие на Power VSX	IBM Power 775 ( PERCS ), 750	IBM BladeCenter PS70x Express	IBM BladeCenter JS2x, JS43	IBM BladeCenter QS22
Общая среда выполнения IBM OpenCL (OCR)	Совместимые с X86 + SSE2 (или выше) процессоры, 64-битные и 32-битные; ПК с Linux 2.6	AMD Fusion , Nvidia Ion и Intel Core i7, i5, i3; Intel Core i7/5/3 2-го поколения	AMD Radeon, Nvidia GeForce и Intel Core 2 Solo, Duo, Quad, Extreme	ATI FirePro, Nvidia Quadro и Intel Xeon 7x00,5x00,3x00 (на базе ядра)
Драйвер и инструменты Nvidia OpenCL , Чипы: Tesla: OpenCL 1.1 (драйвер 340), Fermi: OpenCL 1.1 (драйвер 390), Kepler: OpenCL 1.2 (драйвер 470), бета-версия OpenCL 2.0 (378,66), OpenCL 3.0: от Максвелла до Ады Лавлейс (драйвер 525+)	Нвидиа Тесла C/D/S	NVIDIA GeForce GTS/GT/GTX,	Нвидиа Ион	Nvidia Quadro FX/NVX/Plex, Quadro, Quadro K, Quadro M, Quadro P, Quadro с Volta, Quadro RTX с Turing, Ampere

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

Поддержка версий

Продукты и их версии поддержки OpenCL включают:

Поддержка OpenCL 3.0

Возможно любое оборудование с OpenCL 1.2+, OpenCL 2.x только опционально, Khronos Test Suite доступен с 2020-10 гг.

• (2020) Intel NEO Compute: 20.41+ для Tiger Lake 12-го поколения до Broadwell (включая полную поддержку 2.0 и 2.1, а также части 2.2)
• (2020) Процессоры Intel 6-го, 7-го, 8-го, 9-го, 10-го, 11-го поколения ( Skylake , Kaby Lake , Coffee Lake , Comet Lake , Ice Lake , Tiger Lake ) с новейшим графическим драйвером Intel для Windows
• (2021 г.) Процессоры Intel 11-го, 12-го поколения ( Rocket Lake , Alder Lake ) с новейшим графическим драйвером Intel для Windows
• (2021) Руки Mali-G78, Mali-G310, Mali-G510, Mali-G610, Mali-G710 и Mali-G78AE.
• (2022 г.) Процессоры Intel 13-го поколения ( Raptor Lake ) с новейшим графическим драйвером Intel для Windows
• (2022 г.) Дискретная видеокарта Intel Arc с новейшим графическим драйвером Intel Arc для Windows
• (2021) Nvidia Maxwell , Pascal , Volta , Turing и Ampere с графическим драйвером Nvidia 465+.
• (2022) Nvidia Ada Lovelace с графическим драйвером Nvidia 525+.
• (2022 г.) Графический процессор Samsung Xclipse 920 (на базе AMD RDNA2)
• (2023 г.) Процессоры Intel 14-го поколения ( Raptor Lake ). Обновление с использованием новейшего графического драйвера Intel для Windows.
• (2023 г.) Процессоры Intel Core Ultra Series 1 ( Meteor Lake ) с новейшим графическим драйвером Intel для Windows

Поддержка OpenCL 2.2

Пока нет : Khronos Test Suite готов, с возможностью обновления драйверов всего оборудования с поддержкой версий 2.0 и 2.1.

• Intel NEO Compute: работа над реальными продуктами ведется
• ROCm: в основном версия 3.5+

Поддержка OpenCL 2.1

• (2018+) Поддержка обратного порта на процессоры Intel 5-го и 6-го поколения ( Broadwell , Skylake )
• (2017+) Процессоры Intel 7-го, 8-го, 9-го, 10-го поколения ( Kaby Lake , Coffee Lake , Comet Lake , Ice Lake )
• Khronos: возможно обновление драйверов для всего оборудования с поддержкой версии 2.0.

Поддержка OpenCL 2.0

• (2011+) Графические процессоры AMD GCN (HD 7700+/HD 8000/Rx 200/Rx 300/Rx 400/Rx 500/Rx 5000-Series), некоторые GCN только 1-го поколения 1.2 с некоторыми расширениями
• (2013+) APU AMD GCN ( на базе Jaguar , Steamroller , Puma , Excavator и Zen )
• (2014+) Процессоры Intel 5-го и 6-го поколения ( Broadwell , Skylake )
• (2015+) Серия Qualcomm Adreno 5xx
• (2018+) серия Qualcomm Adreno 6xx
• (2017+) ARM Mali (Bifrost) G51 и G71 в Android 7.1 и Linux
• (2018+) ARM Мали (Бифрост) G31, G52, G72 и G76
• (2017+) поддержка неполной ознакомительной версии: графические процессоры Nvidia Kepler , Maxwell , Pascal , Volta и Turing (GeForce 600, 700, 800, 900 и 10-й серии, Quadro K-, M- и P-серии, Tesla K-, M- и серии P) с драйвером версии 378.66+

Поддержка OpenCL 1.2

• (2011+) для некоторых AMD GCN 1-го поколения, некоторые функции OpenCL 2.0 сегодня недоступны, но гораздо больше расширений, чем Terascale
• (2009+) Графические процессоры AMD TeraScale 2 и 3 (RV8xx, RV9xx в сериях HD 5000, 6000 и 7000)
• (2011+) APU AMD TeraScale ( на базе K10 , Bobcat и Piledriver )
• (2012+) Графические процессоры Nvidia Kepler, Maxwell, Pascal, Volta и Turing (GeForce 600, 700, 800, 900, 10, 16, 20 серий, Quadro K-, M- и P-серии, Tesla K-, M- и P-серия)
• (2012+) Процессоры Intel 3-го и 4-го поколения ( Ivy Bridge , Haswell )
• (2013+) Серия Qualcomm Adreno 4xx
• (2013+) ARM Мали Мидгард 3-го поколения (T760)
• (2015+) ARM Мали Мидгард 4-го поколения (T8xx)

Поддержка OpenCL 1.1

• (2008+) некоторые графические процессоры AMD TeraScale 1 (RV7xx в серии HD4000)
• (2008+) Nvidia Tesla, графические процессоры Fermi (GeForce 8, 9, 100, 200, 300, 400, 500-серия, серия Quadro или серия Tesla с графическим процессором Tesla или Fermi )
• (2011+) серия Qualcomm Adreno 3xx
• (2012+) ARM Mali Midgard 1-го и 2-го поколения (T-6xx, T720)

Поддержка OpenCL 1.0

• в основном обновлен до 1.1 и 1.2 после первого драйвера только для 1.0

Портативность, производительность и альтернативы

Ключевой особенностью OpenCL является переносимость благодаря абстрактной модели памяти и выполнения , и программист не может напрямую использовать аппаратные технологии, такие как встроенное параллельное выполнение потоков (PTX) для графических процессоров Nvidia, если они не готовы отказаться от прямой переносимости. на других платформах. Любое ядро ​​OpenCL можно запустить в любой соответствующей реализации.

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

Исследование, проведенное в Делфтском университете в 2011 году, в котором сравнивались программы CUDA и их прямой перевод в OpenCL C, показало, что CUDA превосходит OpenCL максимум на 30% в реализации Nvidia. Исследователи отметили, что их сравнение можно было бы сделать более справедливым, применив ручную оптимизацию к программам OpenCL, и в этом случае «не было причин, чтобы у OpenCL была худшая производительность, чем у CUDA». Различия в производительности в основном можно объяснить различиями в модели программирования (особенно модели памяти) и оптимизацией компилятора NVIDIA для CUDA по сравнению с оптимизацией для OpenCL.

Другое исследование, проведенное D-Wave Systems Inc., показало, что «производительность ядра OpenCL примерно на 13–63 % медленнее, а сквозное время примерно на 16–67 % медленнее», чем производительность CUDA.

Тот факт, что OpenCL позволяет распределять рабочую нагрузку между ЦП и ГП, выполняя одни и те же программы, означает, что программисты могут использовать оба варианта, разделяя работу между устройствами. Это приводит к проблеме принятия решения о том, как разделить работу, поскольку относительная скорость операций на разных устройствах различается. машинное обучение Для решения этой проблемы было предложено : Греве и О'Бойл описывают систему машин опорных векторов, обученных функциям времени компиляции программы, которые могут решать проблему разделения устройств статически, без фактического запуска программ для измерения их производительности.

При сравнении реальных видеокарт серий AMD RDNA 2 и Nvidia RTX результаты OpenCL-Tests неопределенны. Возможное увеличение производительности за счет использования Nvidia CUDA или OptiX не тестировалось.

См. также

• Расширенная библиотека моделирования
• AMD FireStream
• БрукГПУ
• С++ AMP
• Рядом с металлом
• ДРУГОЙ
• DirectCompute
• ГПГПУ
• БЕДРО
• Ларраби
• Либ Ш
• Список приложений OpenCL
• OpenACC
• OpenGL
• OpenHMPP
• OpenMP
• Металл
• Рендерскрипт
• ПоследовательностьL
• SIMD
• СИКЛ
• Вулкан
• ВебCL

External links

• Official website
• Official website for WebCL
• International Workshop on OpenCL Archived January 26, 2021, at the Wayback Machine (IWOCL) sponsored by The Khronos Group