opencl Tutoriel
Démarrer avec opencl

Remarques

Qu'est ce que OpenCL?

OpenCL est l'abréviation de Open C ute Computing L anguage. OpenCL est un framework pour la programmation parallèle sur des plates-formes hétérogènes, appelées périphériques de calcul , allant des processeurs aux processeurs graphiques, en passant par des plates-formes plus spécifiques telles que les FPGA. OpenCL fournit une interface standard pour le calcul parallèle sur ces périphériques de calcul, mais également un parallélisme inter-périphérique. Il spécifie un langage de programmation basé sur C99 et les exigences minimales des fonctions de base implémentées sur les périphériques compatibles OpenCL. OpenCL décrit en outre un modèle de calcul et de mémoire abstrait, aussi général que possible, afin de faciliter la réutilisation du code entre différentes plates-formes.

Conditions préalables

Si vous avez un processeur ou une carte graphique (GPU) moderne dans votre machine, il est probable que vous ayez tout prêt pour les premiers pas dans OpenCL. Pour savoir si votre processeur est compatible OpenCL, vous pouvez généralement utiliser la page d’accueil du fabricant, la documentation officielle à

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

Qu'est ce que OpenCL?

Open Computing Language (OpenCL) est une structure permettant d'écrire des programmes exécutés sur des processeurs, des processeurs graphiques et d'autres processeurs et accélérateurs parallèles.

OpenCL spécifie un langage de programmation (basé sur C) qui donne accès à une mémoire sur puce nommée, un modèle pour exécuter des tâches en parallèle et la possibilité de synchroniser ces tâches.

Implémentation C # d'OpenCL 1.2: nombre de plates-formes pour un système AMD sous Windows 64 bits

OpenCL est une api de bas niveau, elle doit donc être implémentée dans "l'espace C" en premier. Pour cela, il faut télécharger les fichiers d'en-tête du site de Khronos. Mon matériel est AMD et capable de la version 1.2, téléchargeant

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 cette page

devrait être suffisant pour les liaisons C ++, donc après avoir ajouté ces fichiers à votre projet et défini les emplacements de fichiers binaires (et de bibliothèque) appropriés (

$ (AMDAPPSDKROOT) \ lib \ x86_64 pour la bibliothèque amd 64 bits (les bibliothèques amd app sdk sont préférées)

,

C: \ Windows \ SysWOW64 pour opencl.dll 64 bits (fichier .so si ICD est un système Linux)

Par exemple, mais différent pour Intel-Nvidia), vous pouvez commencer à interroger une liste de plates-formes (amd, intel, xilinx, nvidia) après avoir installé les pilotes appropriés (tels que crimson for amd). Les pilotes sont destinés à exécuter une application opencl (à l'aide d'ICD), les bibliothèques et les fichiers d'en-tête sont destinés au développement.

Pour interroger les plates-formes:

#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;
        }


    }

pourrait être intégré dans une DLL (comme OCLImplementation.dll)

et de l'utiliser du côté 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);
    }
}

bien sûr, la DLL doit être vue par le projet C #, simplement en la mettant près de l'exécutable du projet le résout.

Maintenant, si l'ordinateur dispose d'au moins une plate-forme compatible 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 doit avoir au moins la valeur "1". Vous pouvez ensuite utiliser des plates-formes variables dans C-space en utilisant des fonctions supplémentaires pour parcourir toutes les plates-formes afin d'interroger tous les périphériques tels que les processeurs, les GPU et les accélérateurs spéciaux tels que phi ou fpga.

On n'écrit pas simplement tous ces wrappers C ++ vers C # pour des projets critiques. Il existe de nombreux wrappers écrits pour C #, Java et d'autres langages. Pour Java, il y a "Aparapi" qui est le "java bytecode to opencl-c" convertisseur api qui prend ce que vous écrivez purement en java à une version parallèle à GPU donc il est quelque peu portable.

OpenCL et C #

Pour C #, il existe de nombreux wrappers offrant une interface pour communiquer avec OpenCL.

• OpenCL.NET: C'est l'un des wrappers les plus bas. Il offre une implémentation complète de l'API OpenCL pour C # sans ajouter d'abstraction du tout. Ainsi, les exemples C \ C ++ sont facilement portés pour cette bibliothèque. La seule page de projet est actuellement sur codeplex, qui ferme le 15.12.2017 mais le package est disponible sur NuGet

https://openclnet.codeplex.com/

• NOpenCL: Cette bibliothèque offre une interface abstraite entre C # et OpenCL.

L'objectif à court terme est de fournir une couche abstraite facile à utiliser qui donne accès à toutes les fonctionnalités d'OpenCL sans sacrifier les performances.

https://github.com/tunnelvisionlabs/NOpenCL

• Cloo:

Cloo est une bibliothèque open source, facile à utiliser et gérée qui permet aux applications .NET / Mono de tirer pleinement parti du framework OpenCL.

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