Looking for opencl Answers? Try Ask4KnowledgeBase
Looking for opencl Keywords? Try Ask4Keywords

openclEmpezando con opencl


Observaciones

Esta sección proporciona una descripción general de qué es opencl y por qué un desarrollador puede querer usarlo.

También debe mencionar cualquier tema importante dentro del tema, y ​​vincularlo con los temas relacionados. Dado que la Documentación para opencl es nueva, es posible que deba crear versiones iniciales de los temas relacionados.


Opencl es una api que pone gpus, cpus y algunos otros aceleradores (como un pcie-fpga) en un buen uso de los cálculos tipo C99 pero con una ventaja de concurrencia muy amplia. Una vez que se realiza la instalación y la implementación básica, solo los cambios simples en una cadena del kernel (o su archivo) aplican un algoritmo a N hilos de hardware de forma automática.

Un desarrollador podría querer usarlo porque será mucho más fácil optimizar el espacio o la velocidad de la memoria que hacer lo mismo en opengl o direct-x. También es libre de derechos. La concurrencia dentro de un dispositivo es implícita, por lo que no hay necesidad de múltiples subprocesos explícitos para cada dispositivo. Pero para las configuraciones de múltiples dispositivos, aún se necesita un cpu-multi-threading. Por ejemplo, cuando se envía un trabajo de 1000 hilos a una CPU, el controlador maneja la sincronización de hilos. Simplemente diga qué tan grande debe ser un grupo de trabajo (como 256 cada uno conectado a la memoria local virtual) y dónde están los puntos de sincronización (solo cuando sea necesario).

Usar gpu para operaciones de propósito general es casi siempre más rápido que la CPU. Puede ordenar las cosas más rápido, multiplicar las matrices 10 veces más rápido y unirlas a la izquierda en tablas "sql" en memoria "no". Cualquier gpu de 200 $ para computadoras de escritorio terminará más rápido en una carga de trabajo de física (método de elementos finitos) que cualquier 200 $ cpu. Opencl lo hace más fácil y portátil. Cuando haya terminado de trabajar en C #, puede pasar fácilmente a la implementación de java-opencl utilizando los mismos núcleos y el proyecto de C ++ (por supuesto, utilizando JNI con compilación de C ++ adicional).

Para la parte de gráficos, no siempre tienes que enviar buffers entre cpu y gpu. Puede trabajar puramente en gpu usando la opción "interoperabilidad" en la parte de creación de contexto. Con interoperabilidad, puede preparar geometrías en el rendimiento límite de gpu. No se requiere pci-e para ningún dato de vértice. Solo se envía un "comando" y el trabajo se realiza solo dentro de la tarjeta gráfica. Esto significa que no hay CPU-sobrecarga para los datos. Opencl prepara datos de geometría, opengl los procesa. La CPU se libera. Por ejemplo, si un solo hilo de cpu puede construir una esfera vertical de 32x32 en 10000 ciclos, entonces un gpu con opencl puede construir 20 esferas en 1000 ciclos.


Implementación C # de OpenCL 1.2: número de plataformas para un sistema AMD en ventanas de 64 bits

OpenCL es un api de bajo nivel, por lo que primero debe implementarse en "espacio C". Para eso, uno necesita descargar archivos de cabecera desde el sitio de Khronos. Mi hardware es AMD y capaz de la versión 1.2, descargando

opencl.h 
cl_platform.h 
cl.h 
cl_ext.h 
cl_egl.h 
cl_dx9_media_sharing.h 
cl_d3d10.h 
cl_d3d11.h 
cl_gl.h 
cl_gl_ext.h 
cl.hpp
 

de esta pagina

debería ser suficiente para los enlaces de C ++, así que después de agregar estos archivos a su proyecto y de establecer las ubicaciones de archivos binarios (y de biblioteca) adecuadas (

$ (AMDAPPSDKROOT) \ lib \ x86_64 para la biblioteca amd de 64 bits (se prefieren las bibliotecas amd de la aplicación sdk)

,

C: \ Windows \ SysWOW64 para opencl.dll de 64 bits (archivo .so si ICD es de un sistema Linux)

por ejemplo, pero diferente para Intel-Nvidia), puede comenzar a consultar una lista de plataformas (amd, intel, xilinx, nvidia) después de instalar los controladores adecuados (como carmesí para amd). Los controladores son para ejecutar la aplicación opencl (usando ICD), las bibliotecas y los archivos de encabezado son para que el desarrollo sea breve.

Para consultar plataformas:

#define __CL_ENABLE_EXCEPTIONS
#include "stdafx.h"
#include <vector>
#include <CL/cl.hpp>

extern "C"
    {
       // when this class is created, it contains a list of platforms in "platforms" field.
       class OpenClPlatformList
       {
           public:
               std::vector<cl::Platform> platforms;
               int platformNum;
               OpenClPlatformList()
               {
                   platforms= std::vector< cl::Platform>();
                   cl::Platform::get(&platforms);
                   platformNum= platforms.size();
               }
        };


        // this is seen from C# when imported. Creates an object in memory.
        __declspec(dllexport)
            OpenClPlatformList * createPlatformList()
        {
            return new OpenClPlatformList();
        }

        __declspec(dllexport)
            int platformNumber(OpenClPlatformList * hList)
        {
            return hList->platformNum;
        }


        __declspec(dllexport)
            void deletePlatformList(OpenClPlatformList * p)
        {
            if (p != NULL)
                delete p;
            p = NULL;
        }


    }
 

podría estar integrado en un archivo DLL (como OCLImplementation.dll)

y usarlo desde el lado C #,

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;


namespace WrapperCSharp
{
    public class WrapperCSharp
    {
        [DllImport("OCLImplementation", CallingConvention = CallingConvention.Cdecl)]
        private static extern IntPtr createPlatformList();

        [DllImport("OCLImplementation", CallingConvention = CallingConvention.Cdecl)]
        private static extern int platformNumber(IntPtr hList);

        [DllImport("OCLImplementation", CallingConvention = CallingConvention.Cdecl)]
        private static extern void deletePlatformList(IntPtr hList);
    }
}
 

Por supuesto, el archivo C # debe ver el archivo dll, simplemente colocándolo cerca del ejecutable del proyecto lo resuelve.

Ahora, si la computadora de muestra tiene al menos una plataforma compatible con Opencl,

IntPtr platformList = createPlatformList(); // just an address in C-space
int totalPlatforms = platformNumber(platformList); // AMD+NVIDIA systems should have "2"
deletePlatformList(platformList); //
 

La variable totalPlatforms debe tener al menos el valor "1". Luego, puede usar las plataformas variables en C-space usando funciones adicionales para recorrer en iteración todas las plataformas para consultar todos los dispositivos, como CPU, GPU y aceleradores de propósitos especiales como phi o algunos fpga.

Uno no se limita a escribir todos estos envoltorios de C ++ en C # para proyectos de tiempo crítico. Hay muchos envoltorios escritos para C #, Java y otros lenguajes. Para java, hay "Aparapi" que es el api convertidor de "bycecode java a opencl-c" que lleva lo que se escribe en java a una versión gpu-paralela sobre la marcha, por lo que es algo portátil.

OpenCL y C #

Para C # existen muchos envoltorios que ofrecen una interfaz para comunicarse con OpenCL.

  • OpenCL.NET: este es uno de los envoltorios de nivel más bajo que hay. Ofrece una implementación completa de la API de OpenCL para C # sin agregar ningún tipo de abstracción. Por lo tanto, los ejemplos de C \ C ++ son fácilmente portados para esta biblioteca. La única página de proyecto está actualmente en codeplex, que se cierra el 15.12.2017 pero el paquete está disponible en NuGet

https://openclnet.codeplex.com/

  • NOpenCL: esta biblioteca ofrece una interfaz abstracta entre C # y OpenCL.

El objetivo a corto plazo es proporcionar una capa abstracta fácil de usar que proporcione acceso a toda la capacidad de OpenCL sin sacrificar el rendimiento.

https://github.com/tunnelvisionlabs/NOpenCL

  • Cloo:

Cloo es una biblioteca de código abierto, fácil de usar y administrada que permite que las aplicaciones .NET / Mono aprovechen al máximo el marco OpenCL.

https://sourceforge.net/projects/cloo/

Prerrequisitos

Si tiene una CPU o tarjeta gráfica (GPU) moderna dentro de su máquina, es probable que tenga todo listo para los primeros pasos en OpenCL. Averiguar si su procesador es compatible con OpenCL se puede hacer generalmente a través de la página de inicio del fabricante, un buen comienzo es la documentación oficial en

https://www.khronos.org/conformance/adopters/conformant-products#opencl

¿Qué es OpenCL?

Open Computing Language (OpenCL) es un marco para escribir programas que se ejecutan en CPU, GPU y otros procesadores y aceleradores paralelos.

OpenCL especifica un lenguaje de programación (basado en C) que proporciona acceso a la memoria en chip nombrada, un modelo para ejecutar tareas en paralelo y la capacidad de sincronizar esas tareas.

¿Qué es OpenCL?

OpenCL es la abreviatura de Open C omputing L angguage. OpenCL es un marco para la programación paralela en plataformas heterogéneas, llamadas dispositivos informáticos , que van desde CPUs a través de GPUs a plataformas más especiales como FPGAs. OpenCL proporciona una interfaz estándar para la computación paralela en estos dispositivos informáticos, pero también un paralelismo entre dispositivos. Especifica un lenguaje de programación, basado en C99, y requisitos mínimos de funciones básicas implementadas en dispositivos con capacidad OpenCL. Además, OpenCL describe un modelo abstracto de computación y memoria, siendo lo más general posible para hacer la reutilización de código entre diferentes plataformas de manera directa.