opencl Handledning
Komma igång med opencl

Anmärkningar

Vad är OpenCL?

OpenCL är förkortning för Open C omputing L- språk. OpenCL är ett ramverk för parallell programmering över heterogena plattformar, så kallade datorenheter , från CPU: er över GPU: er till mer speciella plattformar som FPGA: er. OpenCL tillhandahåller ett standardgränssnitt för parallell datoranvändning på dessa datoranordningar, men också inter-enhetens parallellitet. Den anger ett programmeringsspråk, baserat på C99, och minimikrav för basfunktioner implementerade på OpenCL-kapabla enheter. OpenCL beskriver vidare en abstrakt databehandlings- och minnesmodell som är så generell som möjligt för att göra återanvändning av kod mellan olika plattformar enkelt.

förutsättningar

Om du har en modern CPU eller grafikkort (GPU) inuti din maskin, är chansen stor att du har allt redo för de första stegen i OpenCL. Att ta reda på om din processor är OpenCL-kapabel kan vanligtvis göras via tillverkarens hemsida, en bra första start är den officiella dokumentationen på

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

Vad är OpenCL?

Open Computing Language (OpenCL) är ett ramverk för att skriva program som kör på CPU, GPU och andra parallella processorer och acceleratorer.

OpenCL specificerar ett programmeringsspråk (baserat på C) som ger åtkomst till namngivna on-chip-minne, en modell för exekverande av uppgifter parallellt och möjligheten att synkronisera dessa uppgifter.

C # implementering av OpenCL 1.2: antal plattformar för ett AMD-system i 64-bitarsfönster

OpenCL är api på låg nivå så det måste implementeras i "C space" först. För det måste man ladda ner rubrikfiler från Khronos webbplats. Min hårdvara är AMD och kan ladda ner version 1.2

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

från den här sidan

borde vara tillräckligt för C ++ -bindningar så efter att du har lagt till dessa filer i ditt projekt och ställt in korrekt binära (och bibliotek) filplatser (

$ (AMDAPPSDKROOT) \ lib \ x86_64 för 64-bitars amd-bibliotek (amd app sdk's bibliotek föredras)

,

C: \ Windows \ SysWOW64 för 64-bitars opencl.dll (.so-fil om ICD har ett Linux-system)

till exempel men annorlunda för Intel-Nvidia) kan du börja fråga efter en lista med plattformar (amd, Intel, xilinx, nvidia) efter att ha installerat rätt drivrutiner (som Crimson for amd). Drivrutinerna är för att köra opencl-applikation (med ICD), bibliotek och sidfiler är för att utvecklingen ska vara kort.

Så här frågar du plattformar:

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


    }

kan byggas in i en dll (t.ex. OCLImplementation.dll)

och att använda den från C # sida,

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

naturligtvis måste dllen ses av C # -projektet, helt enkelt att sätta det nära körbara projektet löser det.

Nu, om exempeldator har minst en opencl-kapabel plattform,

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

totalPlatforms-variabeln måste ha minst "1" -värde. Sedan kan du använda plattformar som är variabla i C-space genom att använda ytterligare funktioner för att iterera genom alla plattformar för att fråga alla enheter som CPU, GPU och specialacceleratorer som phi eller någon fpga.

Man skriver inte bara alla dessa C ++ till C # -omslag för tidskritiska projekt. Det finns många omslag som är skrivna för C #, Java och andra språk. För java finns det "Aparapi" som är "java bytecode to opencl-c" -konverteraren api som tar det du skriver rent i java till en gpu-parallellversion i farten så att den är något bärbar.

OpenCL och C #

För C # finns det många omslag som erbjuder ett gränssnitt för att kommunicera med OpenCL.

• OpenCL.NET: Detta är en av de mest låga nivåerna som finns där ute. Det erbjuder en fullständig implementering av OpenCL API för C # utan att lägga till någon abstraktion alls. Så C \ C ++-exempel kan enkelt portas för detta bibliotek. Den enda projektsidan finns för närvarande på codeplex, som stängs av 15.12.2017 men paketet är tillgängligt på NuGet

https://openclnet.codeplex.com/

• NOpenCL: Detta bibliotek erbjuder ett abstrakt gränssnitt mellan C # och OpenCL.

Det kortsiktiga målet är att tillhandahålla ett lättanvänt abstrakt lager som ger tillgång till OpenCL: s fulla förmåga utan att offra prestanda.

https://github.com/tunnelvisionlabs/NOpenCL

• Cloo:

Cloo är ett öppet, lättanvänt, hanterat bibliotek som gör det möjligt för .NET / Mono-applikationer att dra full nytta av OpenCL-ramverket.

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