Looking for opencl Keywords? Try Ask4Keywords

openclErste Schritte mit opencl


Bemerkungen

In diesem Abschnitt erhalten Sie einen Überblick darüber, was opencl ist und warum ein Entwickler es verwenden möchte.

Es sollte auch alle großen Themen in opencl erwähnen und auf die verwandten Themen verweisen. Da die Dokumentation für opencl neu ist, müssen Sie möglicherweise erste Versionen dieser verwandten Themen erstellen.


Opencl ist eine API, die gpus, cpus und einige andere Beschleuniger (wie ein pcie-fpga) für C99-ähnliche Berechnungen verwendet, jedoch einen sehr großen Parallelvorteil bietet. Sobald die Installation und grundlegende Implementierung abgeschlossen ist, wenden nur einfache Änderungen in einer Kernel-Zeichenfolge (oder ihrer Datei) einen Algorithmus automatisch auf N Hardware-Threads an.

Ein Entwickler möchte es vielleicht verwenden, weil es viel einfacher ist, den Speicherplatz oder die Geschwindigkeit zu optimieren, als dies bei opengl oder direct-x der Fall ist. Es ist auch gebührenfrei. Parallelität innerhalb eines Geräts ist implizit, sodass kein explizites Multithreading für jedes Gerät erforderlich ist. Für Konfigurationen mit mehreren Geräten ist jedoch weiterhin ein CPU-Multithreading erforderlich. Wenn beispielsweise ein 1000-Thread-Job an eine CPU gesendet wird, wird die Thread-Synchronisierung vom Treiber ausgeführt. Sie sagen nur, wie groß eine Arbeitsgruppe sein sollte (z. B. jeweils 256 mit virtuellem lokalen Speicher verbunden) und wo Synchronisationspunkte sind (nur bei Bedarf).

Die Verwendung von gpu für allgemeine Zwecke ist fast immer schneller als die CPU. Sie können Dinge schneller sortieren, Matrizen 10x schneller multiplizieren und SQL-Tabellen im "Link" in "Nein" zusammenfügen. Jeder 200-Dollar-Desktop-Prozessor wird in einer physischen Workload (Finite-Elemente-Methode) schneller fertig als jeder 200-Dollar-Prozessor. Opencl macht es einfacher und tragbar. Wenn Sie mit der Arbeit in C # fertig sind, können Sie problemlos zur Java-Opencl-Implementierung wechseln, indem Sie dieselben Kernels und C ++ - Projekte verwenden (natürlich mit JNI und zusätzlicher C ++ - Kompilierung).

Für den Grafikteil müssen Sie nicht immer Puffer zwischen CPU und GPU senden. Sie können nur mit gpu arbeiten, indem Sie die Option "interop" im Kontext-Erstellungsteil verwenden. Mit Interop können Sie Geometrien an der Grenzleistung von GPU vorbereiten. Für Scheitelpunktdaten ist keine pci-e erforderlich. Es wird nur ein "Befehl" gesendet, und die Arbeit wird nur innerhalb einer Grafikkarte ausgeführt. Dies bedeutet keinen CPU-Aufwand für Daten. Opencl bereitet Geometriedaten auf, die von opengl ausgegeben werden. CPU wird freigegeben. Wenn zum Beispiel ein einzelner Thread von cpu eine 32x32-verteilte Kugel in 10.000 Zyklen erstellen kann, kann eine gpu mit opencl 20 Kugeln in 1000 Zyklen erstellen.


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/

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.

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.