opencl Tutorial
Erste Schritte mit opencl

Bemerkungen

Was ist OpenCL?

OpenCL ist eine Abkürzung für Open C omputing L. OpenCL ist ein Framework für die parallele Programmierung über heterogene Plattformen, so genannte Rechengeräte , von CPUs über GPUs bis hin zu spezielleren Plattformen wie FPGAs. OpenCL bietet eine Standardschnittstelle für das parallele Rechnen auf diesen Rechengeräten, aber auch die Parallelität zwischen Geräten. Es gibt eine auf C99 basierende Programmiersprache sowie Mindestanforderungen an Basisfunktionen an, die auf OpenCL-fähigen Geräten implementiert sind. OpenCL beschreibt außerdem ein abstraktes Berechnungs- und Speichermodell, das so allgemein wie möglich ist, um die Wiederverwendung von Code zwischen verschiedenen Plattformen zu vereinfachen.

Voraussetzungen

Wenn Sie eine moderne CPU oder Grafikkarte (GPU) in Ihrem Computer haben, haben Sie wahrscheinlich alles für die ersten Schritte in OpenCL bereit. Um herauszufinden, ob Ihr Prozessor OpenCL-fähig ist, können Sie dies normalerweise über die Homepage des Herstellers tun

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

Was ist OpenCL?

Open Computing Language (OpenCL) ist ein Framework zum Schreiben von Programmen, die auf CPUs, GPUs und anderen parallelen Prozessoren und Beschleunigern ausgeführt werden.

OpenCL gibt eine Programmiersprache (basierend auf C) an, die den Zugriff auf benannten Speicher auf dem Chip, ein Modell zur parallelen Ausführung von Aufgaben und die Möglichkeit zur Synchronisierung dieser Aufgaben ermöglicht.

C # -Implementierung von OpenCL 1.2: Anzahl der Plattformen für ein AMD-System in 64-Bit-Fenstern

OpenCL ist eine Low-Level-API, daher muss es zuerst im "C-Space" implementiert werden. Dafür muss man Header-Dateien von der Khronos-Site herunterladen. Meine Hardware ist AMD und kann Version 1.2 herunterladen

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

von dieser Seite

Für C ++ - Bindungen sollte dies ausreichen, nachdem Sie diese Dateien zu Ihrem Projekt hinzugefügt und die richtigen Speicherorte für Binärdateien (und Bibliotheken) festgelegt haben (

$ (AMDAPPSDKROOT) \ lib \ x86_64 für die 64-Bit-Bibliothek amd app (amd app sdk wird bevorzugt)

.

C: \ Windows \ SysWOW64 für 64-Bit-opencl.dll (.so-Datei, wenn der ICD von einem Linux-System stammt)

Zum Beispiel, aber für Intel-Nvidia unterschiedlich), können Sie nach der Installation der richtigen Treiber (z. B. Purpur für AMD) eine Liste von Plattformen abfragen (amd, intel, xilinx, nvidia). Treiber sind für die Ausführung von Opencl-Anwendungen (mit ICD), Bibliotheken und Header-Dateien für die Entwicklung kurz.

Um Plattformen abzufragen:

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


    }

könnte in eine DLL (wie OCLImplementation.dll) eingebaut werden

und von der C # -Seite zu verwenden,

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

Natürlich muss die DLL vom C # -Projekt gesehen werden, indem sie einfach in die Nähe der ausführbaren Datei des Projekts gestellt wird, um es zu lösen.

Wenn nun ein Beispielcomputer über mindestens eine opencl-fähige Plattform verfügt,

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

Die Variable totalPlatforms muss mindestens den Wert "1" haben. Dann können Sie Plattformen verwenden, die im C-Space variabel sind, indem Sie zusätzliche Funktionen verwenden, um alle Plattformen zu durchlaufen, um alle Geräte wie CPU, GPU und Spezialbeschleuniger wie Phi oder einige FPGAs abzufragen.

Alle diese C ++ - Dateien werden nicht einfach in C # - Wrapper für zeitkritische Projekte geschrieben. Es gibt viele Wrapper, die für C #, Java und andere Sprachen geschrieben wurden. Für Java gibt es "Aparapi", also den "Java-Bytecode in Opencl-c" - Konverter, der das, was Sie schreiben, rein in Java zu einer GPU-parallelen Version bringt, also ist es etwas tragbar.

OpenCL und C #

Für C # gibt es viele Wrapper, die eine Schnittstelle für die Kommunikation mit OpenCL bieten.

• OpenCL.NET: Dies ist eine der niedrigsten Wrapper-Versionen. Es bietet eine vollständige Implementierung der OpenCL-API für C #, ohne irgendwelche Abstraktionen hinzuzufügen. Daher können C \ C ++ - Beispiele leicht für diese Bibliothek portiert werden. Die einzige Projektseite ist derzeit auf codeplex, die am 15.12.2017 heruntergefahren wird, das Paket ist jedoch auf NuGet verfügbar

https://openclnet.codeplex.com/

• NOpenCL: Diese Bibliothek bietet eine abstrakte Schnittstelle zwischen C # und OpenCL.

Das kurzfristige Ziel besteht in der Bereitstellung einer benutzerfreundlichen abstrakten Schicht, die den Zugriff auf die vollen Möglichkeiten von OpenCL ohne Leistungseinbußen ermöglicht.

https://github.com/tunnelvisionlabs/NOpenCL

• Cloo:

Cloo ist eine einfach zu bedienende Open Source-Bibliothek, mit der .NET / Mono-Anwendungen das OpenCL-Framework voll ausnutzen können.

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