OpenCL

// Disclaimer: The DllImports below are probably bogus.
public class Context : IDisposable
{
    UnsafeNativeMethods.cl_context context;
 
    public Context(ContextProperties properties)
    {
        context = UnsafeNativeMethods.clCreateContext(...);
    }
 
    unsafe static class UnsafeNativeMethods
    {
         const string library = "opencl.dll";
 
         public struct cl_context { ... }
         public struct cl_context_properties { ... }
         public struct cl_device_id { ... }
 
         public delegate void logging_fn(byte* str, void* p1, IntPtr p2, void* p3);
 
         [DllImport(library), SuppressUnmanagedCodeSecurity]
         public static extern cl_context clCreateContext(
             cl_context_properties properties,
             uint num_devices,
             cl_device_id* devices,
             logging_fn pfn_notify,
             void* user_data,
             int* errorcode_ret);
    }
}

Context context = new Context(...);
context.CreateCommandQueue(...);

public void DotProduct( string[] programSource, float[] srcA, float[] srcB, float[] dst )
{
    Context context;
    CommandQueue cmdQueue;
    Device[] devices;
    Program program;
    Kernel kernel;
    Buffer[] buffers = new Buffer[ 3 ];
    int[] globalWorkSize = new int[]{ srcA.Length };
    int[] localWorkSize = new int[]{ 1 };
 
    context = new Context( Context.Properties.None, Device.Type.Gpu, null, null );
    devices = context.Devices;
 
    cmdQueue = context.CreateCommandQueue( devices[ 0 ], CommandQueue.Properties.None );
 
    buffers[ 0 ] = context.CreateBuffer( Buffer.Flags.ReadOnly | Buffer.Flags.CopyHostPtr, srcA );
    buffers[ 1 ] = context.CreateBuffer( Buffer.Flags.ReadOnly | Buffer.Flags.CopyHostPtr, srcB );
    buffers[ 2 ] = context.CreateBuffer( Buffer.Flags.ReadWrite, null );
 
    program = context.CreateProgram( 1, programSource );
    program.Build( 0, null, null, null, null );
 
    kernel = program.CreateKernel( "dot_product" );
    kernel.SetArgument( 0, buffers[ 0 ] );
    kernel.SetArgument( 1, buffers[ 1 ] );
    kernel.SetArgument( 2, buffers[ 2 ] );
 
    cmdQueue.EnqueNDRangeKernel( kernel, 1, null, globalWorkSize, localWorkSize, null, null );
    cmdQueue.EnqueReadBuffer( buffers[ 2 ], true, 0, dst, null, null );
}

cmdQueue.EnqueNDRangeKernel(
             kernel,
             2, //input data is an image so it has two dimensions. Going to remove (?) because this is a duplicate of arrays lengths
             ...
             int[]{ 100, 200 }, //global work size = image size
             int[]{ 10, 5 },       //local work size
             ...);

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Security;
 
namespace OpenTK.Compute
{
    public class Device
    {
        UIntPtr handle;
 
        static Dictionary<Type, Device[]> typeToDevices = new Dictionary<Type, Device[]>();
 
        // every Info item gets its property
        //...
        public bool EndianLittle { get { return GetInfo<bool>( Info.EndianLittle ); } }
        public string Vendor { get { return GetInfo<string>( Info.Vendor ); } }
        //...        
 
        // same goes for all other non bitfield enums.
 
        public static IEnumerable<Device> GetDevices( Type type )
        {
            // Check whether we have already queried this type.
            if( typeToDevices.ContainsKey( type ) )
                return typeToDevices[ type ];
 
            // Citing the specs:
            // ...returns CL_INVALID_VALUE if num_entries is equal to zero and devices 
            // is not NULL or if both num_devices and devices are NULL...
            // Where did you see this usage Fiddler? Does "zero + null"
            // get you the device count of a type?
 
            // Ensure size of the devices array.
            uint deviceCount;
            Tools.CheckErrorCode( UnsafeNativeMethods.clGetDeviceIds( type, 0, null, out deviceCount ) );
            if( deviceCount == 0 )
                return new Device[ 0 ];
            Device[] devices = new Device[ deviceCount ];
 
            // Get the actual matching devices and cache the result.
            Tools.CheckErrorCode( UnsafeNativeMethods.clGetDeviceIds( type, ( uint )devices.Length, devices, out deviceCount ) );
            typeToDevices[ type ] = devices;
 
            return devices;
        }
 
        private RetType GetInfo<RetType>( Info info )
        {
            RetType result = default( RetType ); // shut up the compiler
 
            // same pattern as above
            UIntPtr retSize;
            Tools.CheckErrorCode( UnsafeNativeMethods.clGetDeviceInfo( this, info, UIntPtr.Zero, null, out retSize ) );
 
            // Yes, I know this doesn't work, but I need a way of telling what I want to do.
            // Sooo, what here? A huge "info"-based switch? Or some InteropServices woodoo?
            // Tools.CheckErrorCode(
            //        UnsafeNativeMethods.clGetDeviceInfo(
            //                this,
            //                info,
            //                retSize,
            //                ( object )result,
            //                out retSize 
            //        )
            //);
            return result;
        }
 
        private static unsafe class UnsafeNativeMethods
        {
            //extern CL_API_ENTRY cl_int CL_API_CALL
            //clGetDeviceIDs(
            //      cl_device_type  device_type,
            //      cl_uint         num_entries,
            //      cl_device_id *  devices,
            //      cl_uint *       num_devices ); CL_API_SUFFIX__VERSION_1_0;
 
            [DllImport( "opencl.dll" ), SuppressUnmanagedCodeSecurity]
            internal static extern ErrorCode clGetDeviceIds( 
                    Type type,
                    UInt32 numEntries,
                    [Out] Device[] devices,
                    out UInt32 numDevices );
 
            //extern CL_API_ENTRY cl_int CL_API_CALL
            //clGetDeviceInfo(
            //      cl_device_id    device
            //      cl_device_info  param_name,
            //      size_t          param_value_size,
            //      void *          param_value,
            //      size_t *        param_value_size_ret ); CL_API_SUFFIX__VERSION_1_0;
 
            [DllImport( "opencl.dll" ), SuppressUnmanagedCodeSecurity]
            internal static extern ErrorCode clGetDeviceInfo(
                    Device device,
                    Info info,
                    // What with size_t's? AFAIK UIntPtr is the closest match. Better ideas?
                    UIntPtr valueSize,      
                    // The function returns several types, ranging from bool to string. 
                    [Out] object value,       
                    out UIntPtr valueSizeRet );
        }
 
        [Flags]
        public enum FpConfig
        {
            Denorm = ( 1 << 0 ),
            InfNan = ( 1 << 1 ),
            RoundToNearest = ( 1 << 2 ),
            RoundToZero = ( 1 << 3 ),
            RoundToInf = ( 1 << 4 ),
            Fma = ( 1 << 5 ),
        }
 
        // This goes private too. Properties will supply the requested info
        public enum Info
        {
            Type = 0x1000,
            VendorId = 0x1001,
            MaxComputeUnits = 0x1002,
            MaxWorkItemDimensions = 0x1003,
            MaxWorkGroupSize = 0x1004,
            MaxWorkItemSizes = 0x1005,
            PreferredVectorWidthChar = 0x1006,
            PreferredVectorWidthShort = 0x1007,
            PreferredVectorWidthInt = 0x1008,
            PreferredVectorWidthLong = 0x1009,
            PreferredVectorWidthFloat = 0x100A,
            PreferredVectorWidthDouble = 0x100B,
            MaxClockFrequency = 0x100C,
            AddressBits = 0x100D,
            MaxReadImageArgs = 0x100E,
            MaxWriteImageArgs = 0x100F,
            MaxMemAllocSize = 0x1010,
            Image2dMaxWidth = 0x1011,
            Image2dMaxHeight = 0x1012,
            Image3dMaxWidth = 0x1013,
            Image3dMaxHeight = 0x1014,
            Image3dMaxDepth = 0x1015,
            ImageSupport = 0x1016,
            MaxParameterSize = 0x1017,
            MaxSamplers = 0x1018,
            MemBaseAddrAlign = 0x1019,
            MaxDataTypeAlignSize = 0x101A,
            SingleFpConfig = 0x101B,
            GlobalMemCacheType = 0x101C,
            GlobalMemCachelineSize = 0x101D,
            GlobalMemCacheSize = 0x101E,
            GlobalMemSize = 0x101F,
            MaxConstantBufferSize = 0x1020,
            MaxConstantArgs = 0x1021,
            LocalMemType = 0x1022,
            LocalMemSize = 0x1023,
            ErrorCorrectionSupport = 0x1024,
            ProfilingTimerResolution = 0x1025,
            EndianLittle = 0x1026,
            Available = 0x1027,
            CompilerAvailable = 0x1028,
            ExecutionCapabilities = 0x1029,
            QueueProperties = 0x102A,
            Name = 0x102B,
            Vendor = 0x102C,
            DriverVersion = 0x102D,
            Profile = 0x102E,
            Version = 0x102F,
            Extensions = 0x1030,
        }
 
        // more enums
        // ...
    }
}